Merge branch 'master' into set_binds

* master: (2794 commits)
  doc, API example on how to use `Model#exists?` with multiple IDs. [ci skip]
  Restore DATABASE_URL even if it's nil in connection_handler test
  [ci skip] - error_messages_for has been deprecated since 2.3.8 - lets reduce any confusion for users
  Ensure Active Record connection consistency
  Revert "ask the fixture set for the sql statements"
  Check `respond_to` before delegation due to: https://github.com/ruby/ruby/commit/d781caaf313b8649948c107bba277e5ad7307314
  Adding Hash#compact and Hash#compact! methods
  MySQL version 4.1 was EOL on December 31, 2009 We should at least recommend modern versions of MySQL to users.
  clear cache on body close so that cache remains during rendering
  add a more restricted codepath for templates fixes #13390
  refactor generator tests to use block form of Tempfile
  Fix typo [ci skip]
  Move finish_template as the last public method in the generator
  Minor typos fix [ci skip]
  make `change_column_null` reversible. Closes #13576.
  create/drop test and development databases only if RAILS_ENV is nil
  Revert "Speedup String#to"
  typo fix in test name. [ci skip].
  `core_ext/string/access.rb` test what we are documenting.
  Fix typo in image_tag documentation
  ...

Conflicts:
	activerecord/lib/active_record/associations/join_dependency/join_association.rb
	activerecord/lib/active_record/relation/query_methods.rb

278 files changed, 2079 insertions, 20440 deletions

diff --git a/actionpack/test/abstract/abstract_controller_test.rb b/actionpack/test/abstract/abstract_controller_test.rb
deleted file mode 100644
index eb9143c8f6..0000000000
--- a/actionpack/test/abstract/abstract_controller_test.rb
+++ /dev/null
@@ -1,261 +0,0 @@
-require 'abstract_unit'
-require 'set'
-
-module AbstractController
-  module Testing
-
-    # Test basic dispatching.
-    # ====
-    # * Call process
-    # * Test that the response_body is set correctly
-    class SimpleController < AbstractController::Base
-    end
-
-    class Me < SimpleController
-      def index
-        self.response_body = "Hello world"
-        "Something else"
-      end
-    end
-
-    class TestBasic < ActiveSupport::TestCase
-      test "dispatching works" do
-        controller = Me.new
-        controller.process(:index)
-        assert_equal "Hello world", controller.response_body
-      end
-    end
-
-    # Test Render mixin
-    # ====
-    class RenderingController < AbstractController::Base
-      include AbstractController::Rendering
-
-      def _prefixes
-        []
-      end
-
-      def render(options = {})
-        if options.is_a?(String)
-          options = {:_template_name => options}
-        end
-        super
-      end
-
-      append_view_path File.expand_path(File.join(File.dirname(__FILE__), "views"))
-    end
-
-    class Me2 < RenderingController
-      def index
-        render "index.erb"
-      end
-
-      def index_to_string
-        self.response_body = render_to_string "index"
-      end
-
-      def action_with_ivars
-        @my_ivar = "Hello"
-        render "action_with_ivars.erb"
-      end
-
-      def naked_render
-        render
-      end
-
-      def rendering_to_body
-        self.response_body = render_to_body :template => "naked_render"
-      end
-
-      def rendering_to_string
-        self.response_body = render_to_string :template => "naked_render"
-      end
-    end
-
-    class TestRenderingController < ActiveSupport::TestCase
-      def setup
-        @controller = Me2.new
-      end
-
-      test "rendering templates works" do
-        @controller.process(:index)
-        assert_equal "Hello from index.erb", @controller.response_body
-      end
-
-      test "render_to_string works with a String as an argument" do
-        @controller.process(:index_to_string)
-        assert_equal "Hello from index.erb", @controller.response_body
-      end
-
-      test "rendering passes ivars to the view" do
-        @controller.process(:action_with_ivars)
-        assert_equal "Hello from index_with_ivars.erb", @controller.response_body
-      end
-
-      test "rendering with no template name" do
-        @controller.process(:naked_render)
-        assert_equal "Hello from naked_render.erb", @controller.response_body
-      end
-
-      test "rendering to a rack body" do
-        @controller.process(:rendering_to_body)
-        assert_equal "Hello from naked_render.erb", @controller.response_body
-      end
-
-      test "rendering to a string" do
-        @controller.process(:rendering_to_string)
-        assert_equal "Hello from naked_render.erb", @controller.response_body
-      end
-    end
-
-    # Test rendering with prefixes
-    # ====
-    # * self._prefix is used when defined
-    class PrefixedViews < RenderingController
-      private
-      def self.prefix
-        name.underscore
-      end
-
-      def _prefixes
-        [self.class.prefix]
-      end
-    end
-
-    class Me3 < PrefixedViews
-      def index
-        render
-      end
-
-      def formatted
-        self.formats = [:html]
-        render
-      end
-    end
-
-    class TestPrefixedViews < ActiveSupport::TestCase
-      def setup
-        @controller = Me3.new
-      end
-
-      test "templates are located inside their 'prefix' folder" do
-        @controller.process(:index)
-        assert_equal "Hello from me3/index.erb", @controller.response_body
-      end
-
-      test "templates included their format" do
-        @controller.process(:formatted)
-        assert_equal "Hello from me3/formatted.html.erb", @controller.response_body
-      end
-    end
-
-    # Test rendering with layouts
-    # ====
-    # self._layout is used when defined
-    class WithLayouts < PrefixedViews
-      include AbstractController::Layouts
-
-      private
-      def self.layout(formats)
-        find_template(name.underscore, {:formats => formats}, :_prefixes => ["layouts"])
-      rescue ActionView::MissingTemplate
-        begin
-          find_template("application", {:formats => formats}, :_prefixes => ["layouts"])
-        rescue ActionView::MissingTemplate
-        end
-      end
-
-      def render_to_body(options = {})
-        options[:_layout] = options[:layout] || _default_layout({})
-        super
-      end
-    end
-
-    class Me4 < WithLayouts
-      def index
-        render
-      end
-    end
-
-    class TestLayouts < ActiveSupport::TestCase
-      test "layouts are included" do
-        controller = Me4.new
-        controller.process(:index)
-        assert_equal "Me4 Enter : Hello from me4/index.erb : Exit", controller.response_body
-      end
-    end
-
-    # respond_to_action?(action_name)
-    # ====
-    # * A method can be used as an action only if this method
-    #   returns true when passed the method name as an argument
-    # * Defaults to true in AbstractController
-    class DefaultRespondToActionController < AbstractController::Base
-      def index() self.response_body = "success" end
-    end
-
-    class ActionMissingRespondToActionController < AbstractController::Base
-      # No actions
-    private
-      def action_missing(action_name)
-        self.response_body = "success"
-      end
-    end
-
-    class RespondToActionController < AbstractController::Base;
-      def index() self.response_body = "success" end
-
-      def fail()  self.response_body = "fail"    end
-
-    private
-
-      def method_for_action(action_name)
-        action_name.to_s != "fail" && action_name
-      end
-    end
-
-    class TestRespondToAction < ActiveSupport::TestCase
-
-      def assert_dispatch(klass, body = "success", action = :index)
-        controller = klass.new
-        controller.process(action)
-        assert_equal body, controller.response_body
-      end
-
-      test "an arbitrary method is available as an action by default" do
-        assert_dispatch DefaultRespondToActionController, "success", :index
-      end
-
-      test "raises ActionNotFound when method does not exist and action_missing is not defined" do
-        assert_raise(ActionNotFound) { DefaultRespondToActionController.new.process(:fail) }
-      end
-
-      test "dispatches to action_missing when method does not exist and action_missing is defined" do
-        assert_dispatch ActionMissingRespondToActionController, "success", :ohai
-      end
-
-      test "a method is available as an action if method_for_action returns true" do
-        assert_dispatch RespondToActionController, "success", :index
-      end
-
-      test "raises ActionNotFound if method is defined but method_for_action returns false" do
-        assert_raise(ActionNotFound) { RespondToActionController.new.process(:fail) }
-      end
-    end
-
-    class Me6 < AbstractController::Base
-      self.action_methods
-
-      def index
-      end
-    end
-
-    class TestActionMethodsReloading < ActiveSupport::TestCase
-
-      test "action_methods should be reloaded after defining a new method" do
-        assert_equal Set.new(["index"]), Me6.action_methods
-      end
-    end
-
-  end
-end
diff --git a/actionpack/test/abstract/collector_test.rb b/actionpack/test/abstract/collector_test.rb
index 5709ad0378..b1a5044399 100644
--- a/actionpack/test/abstract/collector_test.rb
+++ b/actionpack/test/abstract/collector_test.rb
@@ -37,7 +37,7 @@ module AbstractController
 
       test "does not register unknown mime types" do
         collector = MyCollector.new
-        assert_raise NameError do
+        assert_raise NoMethodError do
           collector.unknown
         end
       end
diff --git a/actionpack/test/abstract/helper_test.rb b/actionpack/test/abstract/helper_test.rb
deleted file mode 100644
index 7960e5b55b..0000000000
--- a/actionpack/test/abstract/helper_test.rb
+++ /dev/null
@@ -1,101 +0,0 @@
-require 'abstract_unit'
-
-ActionController::Base.helpers_path = File.expand_path('../../fixtures/helpers', __FILE__)
-
-module AbstractController
-  module Testing
-
-    class ControllerWithHelpers < AbstractController::Base
-      include AbstractController::Rendering
-      include AbstractController::Helpers
-
-      def with_module
-        render :inline => "Module <%= included_method %>"
-      end
-    end
-
-    module HelperyTest
-      def included_method
-        "Included"
-      end
-    end
-
-    class AbstractHelpers < ControllerWithHelpers
-      helper(HelperyTest) do
-        def helpery_test
-          "World"
-        end
-      end
-
-      helper :abc
-
-      def with_block
-        render :inline => "Hello <%= helpery_test %>"
-      end
-
-      def with_symbol
-        render :inline => "I respond to bare_a: <%= respond_to?(:bare_a) %>"
-      end
-    end
-
-    class ::HelperyTestController < AbstractHelpers
-      clear_helpers
-    end
-
-    class AbstractHelpersBlock < ControllerWithHelpers
-      helper do
-        include AbstractController::Testing::HelperyTest
-      end
-    end
-
-    class TestHelpers < ActiveSupport::TestCase
-      def setup
-        @controller = AbstractHelpers.new
-      end
-
-      def test_helpers_with_block
-        @controller.process(:with_block)
-        assert_equal "Hello World", @controller.response_body
-      end
-
-      def test_helpers_with_module
-        @controller.process(:with_module)
-        assert_equal "Module Included", @controller.response_body
-      end
-
-      def test_helpers_with_symbol
-        @controller.process(:with_symbol)
-        assert_equal "I respond to bare_a: true", @controller.response_body
-      end
-
-      def test_declare_missing_helper
-        AbstractHelpers.helper :missing
-        flunk "should have raised an exception"
-      rescue LoadError => e
-        assert_equal "helpers/missing_helper.rb", e.path
-      end
-
-      def test_helpers_with_module_through_block
-        @controller = AbstractHelpersBlock.new
-        @controller.process(:with_module)
-        assert_equal "Module Included", @controller.response_body
-      end
-    end
-
-    class ClearHelpersTest < ActiveSupport::TestCase
-      def setup
-        @controller = HelperyTestController.new
-      end
-
-      def test_clears_up_previous_helpers
-        @controller.process(:with_symbol)
-        assert_equal "I respond to bare_a: false", @controller.response_body
-      end
-
-      def test_includes_controller_default_helper
-        @controller.process(:with_block)
-        assert_equal "Hello Default", @controller.response_body
-      end
-    end
-  end
-end
diff --git a/actionpack/test/abstract/layouts_test.rb b/actionpack/test/abstract/layouts_test.rb
deleted file mode 100644
index 4a05c00f8b..0000000000
--- a/actionpack/test/abstract/layouts_test.rb
+++ /dev/null
@@ -1,383 +0,0 @@
-require 'abstract_unit'
-
-module AbstractControllerTests
-  module Layouts
-
-    # Base controller for these tests
-    class Base < AbstractController::Base
-      include AbstractController::Rendering
-      include AbstractController::Layouts
-
-      abstract!
-
-      self.view_paths = [ActionView::FixtureResolver.new(
-        "layouts/hello.erb"             => "With String <%= yield %>",
-        "layouts/hello_override.erb"    => "With Override <%= yield %>",
-        "layouts/overwrite.erb"         => "Overwrite <%= yield %>",
-        "layouts/with_false_layout.erb" => "False Layout <%= yield %>",
-        "abstract_controller_tests/layouts/with_string_implied_child.erb" =>
-                                           "With Implied <%= yield %>",
-        "abstract_controller_tests/layouts/with_grand_child_of_implied.erb" =>
-                                           "With Grand Child <%= yield %>"
-
-      )]
-    end
-
-    class Blank < Base
-      self.view_paths = []
-
-      def index
-        render :template => ActionView::Template::Text.new("Hello blank!")
-      end
-    end
-
-    class WithString < Base
-      layout "hello"
-
-      def index
-        render :template => ActionView::Template::Text.new("Hello string!")
-      end
-
-      def overwrite_default
-        render :template => ActionView::Template::Text.new("Hello string!"), :layout => :default
-      end
-
-      def overwrite_false
-        render :template => ActionView::Template::Text.new("Hello string!"), :layout => false
-      end
-
-      def overwrite_string
-        render :template => ActionView::Template::Text.new("Hello string!"), :layout => "overwrite"
-      end
-
-      def overwrite_skip
-        render :text => "Hello text!"
-      end
-    end
-
-    class WithStringChild < WithString
-    end
-
-    class WithStringOverriddenChild < WithString
-      layout "hello_override"
-    end
-
-    class WithStringImpliedChild < WithString
-      layout nil
-    end
-
-    class WithChildOfImplied < WithStringImpliedChild
-    end
-
-    class WithGrandChildOfImplied < WithStringImpliedChild
-      layout nil
-    end
-
-    class WithProc < Base
-      layout proc { "overwrite" }
-
-      def index
-        render :template => ActionView::Template::Text.new("Hello proc!")
-      end
-    end
-
-    class WithProcReturningNil < Base
-      layout proc { nil }
-
-      def index
-        render template: ActionView::Template::Text.new("Hello nil!")
-      end
-    end
-
-    class WithZeroArityProc < Base
-      layout proc { "overwrite" }
-
-      def index
-        render :template => ActionView::Template::Text.new("Hello zero arity proc!")
-      end
-    end
-
-    class WithProcInContextOfInstance < Base
-      def an_instance_method; end
-
-      layout proc {
-        break unless respond_to? :an_instance_method
-        "overwrite"
-      }
-
-      def index
-        render :template => ActionView::Template::Text.new("Hello again zero arity proc!")
-      end
-    end
-
-    class WithSymbol < Base
-      layout :hello
-
-      def index
-        render :template => ActionView::Template::Text.new("Hello symbol!")
-      end
-    private
-      def hello
-        "overwrite"
-      end
-    end
-
-    class WithSymbolReturningNil < Base
-      layout :nilz
-
-      def index
-        render :template => ActionView::Template::Text.new("Hello nilz!")
-      end
-
-      def nilz() end
-    end
-
-    class WithSymbolReturningObj < Base
-      layout :objekt
-
-      def index
-        render :template => ActionView::Template::Text.new("Hello nilz!")
-      end
-
-      def objekt
-        Object.new
-      end
-    end
-
-    class WithSymbolAndNoMethod < Base
-      layout :no_method
-
-      def index
-        render :template => ActionView::Template::Text.new("Hello boom!")
-      end
-    end
-
-    class WithMissingLayout < Base
-      layout "missing"
-
-      def index
-        render :template => ActionView::Template::Text.new("Hello missing!")
-      end
-    end
-
-    class WithFalseLayout < Base
-      layout false
-
-      def index
-        render :template => ActionView::Template::Text.new("Hello false!")
-      end
-    end
-
-    class WithNilLayout < Base
-      layout nil
-
-      def index
-        render :template => ActionView::Template::Text.new("Hello nil!")
-      end
-    end
-
-    class WithOnlyConditional < WithStringImpliedChild
-      layout "overwrite", :only => :show
-
-      def index
-        render :template => ActionView::Template::Text.new("Hello index!")
-      end
-
-      def show
-        render :template => ActionView::Template::Text.new("Hello show!")
-      end
-    end
-
-    class WithExceptConditional < WithStringImpliedChild
-      layout "overwrite", :except => :show
-
-      def index
-        render :template => ActionView::Template::Text.new("Hello index!")
-      end
-
-      def show
-        render :template => ActionView::Template::Text.new("Hello show!")
-      end
-    end
-
-    class TestBase < ActiveSupport::TestCase
-      test "when no layout is specified, and no default is available, render without a layout" do
-        controller = Blank.new
-        controller.process(:index)
-        assert_equal "Hello blank!", controller.response_body
-      end
-
-      test "when layout is specified as a string, render with that layout" do
-        controller = WithString.new
-        controller.process(:index)
-        assert_equal "With String Hello string!", controller.response_body
-      end
-
-      test "when layout is overwriten by :default in render, render default layout" do
-        controller = WithString.new
-        controller.process(:overwrite_default)
-        assert_equal "With String Hello string!", controller.response_body
-      end
-
-      test "when layout is overwriten by string in render, render new layout" do
-        controller = WithString.new
-        controller.process(:overwrite_string)
-        assert_equal "Overwrite Hello string!", controller.response_body
-      end
-
-      test "when layout is overwriten by false in render, render no layout" do
-        controller = WithString.new
-        controller.process(:overwrite_false)
-        assert_equal "Hello string!", controller.response_body
-      end
-
-      test "when text is rendered, render no layout" do
-        controller = WithString.new
-        controller.process(:overwrite_skip)
-        assert_equal "Hello text!", controller.response_body
-      end
-
-      test "when layout is specified as a string, but the layout is missing, raise an exception" do
-        assert_raises(ActionView::MissingTemplate) { WithMissingLayout.new.process(:index) }
-      end
-
-      test "when layout is specified as false, do not use a layout" do
-        controller = WithFalseLayout.new
-        controller.process(:index)
-        assert_equal "Hello false!", controller.response_body
-      end
-
-      test "when layout is specified as nil, do not use a layout" do
-        controller = WithNilLayout.new
-        controller.process(:index)
-        assert_equal "Hello nil!", controller.response_body
-      end
-
-      test "when layout is specified as a proc, do not leak any methods into controller's action_methods" do
-        assert_equal Set.new(['index']), WithProc.action_methods
-      end
-
-      test "when layout is specified as a proc, call it and use the layout returned" do
-        controller = WithProc.new
-        controller.process(:index)
-        assert_equal "Overwrite Hello proc!", controller.response_body
-      end
-
-      test "when layout is specified as a proc and the proc retuns nil, don't use a layout" do
-        controller = WithProcReturningNil.new
-        controller.process(:index)
-        assert_equal "Hello nil!", controller.response_body
-      end
-
-      test "when layout is specified as a proc without parameters it works just the same" do
-        controller = WithZeroArityProc.new
-        controller.process(:index)
-        assert_equal "Overwrite Hello zero arity proc!", controller.response_body
-      end
-
-      test "when layout is specified as a proc without parameters the block is evaluated in the context of an instance" do
-        controller = WithProcInContextOfInstance.new
-        controller.process(:index)
-        assert_equal "Overwrite Hello again zero arity proc!", controller.response_body
-      end
-
-      test "when layout is specified as a symbol, call the requested method and use the layout returned" do
-        controller = WithSymbol.new
-        controller.process(:index)
-        assert_equal "Overwrite Hello symbol!", controller.response_body
-      end
-
-      test "when layout is specified as a symbol and the method returns nil, don't use a layout" do
-        controller = WithSymbolReturningNil.new
-        controller.process(:index)
-        assert_equal "Hello nilz!", controller.response_body
-      end
-
-      test "when the layout is specified as a symbol and the method doesn't exist, raise an exception" do
-        assert_raises(NameError) { WithSymbolAndNoMethod.new.process(:index) }
-      end
-
-      test "when the layout is specified as a symbol and the method returns something besides a string/false/nil, raise an exception" do
-        assert_raises(ArgumentError) { WithSymbolReturningObj.new.process(:index) }
-      end
-
-      test "when a child controller does not have a layout, use the parent controller layout" do
-        controller = WithStringChild.new
-        controller.process(:index)
-        assert_equal "With String Hello string!", controller.response_body
-      end
-
-      test "when a child controller has specified a layout, use that layout and not the parent controller layout" do
-        controller = WithStringOverriddenChild.new
-        controller.process(:index)
-        assert_equal "With Override Hello string!", controller.response_body
-      end
-
-      test "when a child controller has an implied layout, use that layout and not the parent controller layout" do
-        controller = WithStringImpliedChild.new
-        controller.process(:index)
-        assert_equal "With Implied Hello string!", controller.response_body
-      end
-
-      test "when a grandchild has no layout specified, the child has an implied layout, and the " \
-        "parent has specified a layout, use the child controller layout" do
-          controller = WithChildOfImplied.new
-          controller.process(:index)
-          assert_equal "With Implied Hello string!", controller.response_body
-      end
-
-      test "when a grandchild has nil layout specified, the child has an implied layout, and the " \
-        "parent has specified a layout, use the child controller layout" do
-          controller = WithGrandChildOfImplied.new
-          controller.process(:index)
-          assert_equal "With Grand Child Hello string!", controller.response_body
-      end
-
-      test "raises an exception when specifying layout true" do
-        assert_raises ArgumentError do
-          Object.class_eval do
-            class ::BadFailLayout < AbstractControllerTests::Layouts::Base
-              layout true
-            end
-          end
-        end
-      end
-
-      test "when specify an :only option which match current action name" do
-        controller = WithOnlyConditional.new
-        controller.process(:show)
-        assert_equal "Overwrite Hello show!", controller.response_body
-      end
-
-      test "when specify an :only option which does not match current action name" do
-        controller = WithOnlyConditional.new
-        controller.process(:index)
-        assert_equal "With Implied Hello index!", controller.response_body
-      end
-
-      test "when specify an :except option which match current action name" do
-        controller = WithExceptConditional.new
-        controller.process(:show)
-        assert_equal "With Implied Hello show!", controller.response_body
-      end
-
-      test "when specify an :except option which does not match current action name" do
-        controller = WithExceptConditional.new
-        controller.process(:index)
-        assert_equal "Overwrite Hello index!", controller.response_body
-      end
-
-      test "layout for anonymous controller" do
-        klass = Class.new(WithString) do
-          def index
-            render :text => 'index', :layout => true
-          end
-        end
-
-        controller = klass.new
-        controller.process(:index)
-        assert_equal "With String index", controller.response_body
-      end
-    end
-  end
-end
diff --git a/actionpack/test/abstract/render_test.rb b/actionpack/test/abstract/render_test.rb
deleted file mode 100644
index b9293d1241..0000000000
--- a/actionpack/test/abstract/render_test.rb
+++ /dev/null
@@ -1,102 +0,0 @@
-require 'abstract_unit'
-
-module AbstractController
-  module Testing
-
-    class ControllerRenderer < AbstractController::Base
-      include AbstractController::Rendering
-
-      def _prefixes
-        %w[renderer]
-      end
-
-      self.view_paths = [ActionView::FixtureResolver.new(
-        "template.erb" => "With Template",
-        "renderer/default.erb" => "With Default",
-        "renderer/string.erb" => "With String",
-        "renderer/symbol.erb" => "With Symbol",
-        "string/with_path.erb" => "With String With Path",
-        "some/file.erb" => "With File"
-      )]
-
-      def template
-        render :template => "template"
-      end
-
-      def file
-        render :file => "some/file"
-      end
-
-      def inline
-        render :inline => "With <%= :Inline %>"
-      end
-
-      def text
-        render :text => "With Text"
-      end
-
-      def default
-        render
-      end
-
-      def string
-        render "string"
-      end
-
-      def string_with_path
-        render "string/with_path"
-      end
-
-      def symbol
-        render :symbol
-      end
-    end
-
-    class TestRenderer < ActiveSupport::TestCase
-
-      def setup
-        @controller = ControllerRenderer.new
-      end
-
-      def test_render_template
-        @controller.process(:template)
-        assert_equal "With Template", @controller.response_body
-      end
-
-      def test_render_file
-        @controller.process(:file)
-        assert_equal "With File", @controller.response_body
-      end
-
-      def test_render_inline
-        @controller.process(:inline)
-        assert_equal "With Inline", @controller.response_body
-      end
-
-      def test_render_text
-        @controller.process(:text)
-        assert_equal "With Text", @controller.response_body
-      end
-
-      def test_render_default
-        @controller.process(:default)
-        assert_equal "With Default", @controller.response_body
-      end
-
-      def test_render_string
-        @controller.process(:string)
-        assert_equal "With String", @controller.response_body
-      end
-
-      def test_render_symbol
-        @controller.process(:symbol)
-        assert_equal "With Symbol", @controller.response_body
-      end
-
-      def test_render_string_with_path
-        @controller.process(:string_with_path)
-        assert_equal "With String With Path", @controller.response_body
-      end
-    end
-  end
-end
diff --git a/actionpack/test/abstract/views/abstract_controller/testing/me3/formatted.html.erb b/actionpack/test/abstract/views/abstract_controller/testing/me3/formatted.html.erb
deleted file mode 100644
index 785bf69191..0000000000
--- a/actionpack/test/abstract/views/abstract_controller/testing/me3/formatted.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-Hello from me3/formatted.html.erb
\ No newline at end of file
diff --git a/actionpack/test/abstract/views/abstract_controller/testing/me3/index.erb b/actionpack/test/abstract/views/abstract_controller/testing/me3/index.erb
deleted file mode 100644
index f079ad8204..0000000000
--- a/actionpack/test/abstract/views/abstract_controller/testing/me3/index.erb
+++ /dev/null
@@ -1 +0,0 @@
-Hello from me3/index.erb
\ No newline at end of file
diff --git a/actionpack/test/abstract/views/abstract_controller/testing/me4/index.erb b/actionpack/test/abstract/views/abstract_controller/testing/me4/index.erb
deleted file mode 100644
index 89dce12bdc..0000000000
--- a/actionpack/test/abstract/views/abstract_controller/testing/me4/index.erb
+++ /dev/null
@@ -1 +0,0 @@
-Hello from me4/index.erb
\ No newline at end of file
diff --git a/actionpack/test/abstract/views/abstract_controller/testing/me5/index.erb b/actionpack/test/abstract/views/abstract_controller/testing/me5/index.erb
deleted file mode 100644
index 84d0b7417e..0000000000
--- a/actionpack/test/abstract/views/abstract_controller/testing/me5/index.erb
+++ /dev/null
@@ -1 +0,0 @@
-Hello from me5/index.erb
\ No newline at end of file
diff --git a/actionpack/test/abstract/views/action_with_ivars.erb b/actionpack/test/abstract/views/action_with_ivars.erb
deleted file mode 100644
index 8d8ae22fd7..0000000000
--- a/actionpack/test/abstract/views/action_with_ivars.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= @my_ivar %> from index_with_ivars.erb
\ No newline at end of file
diff --git a/actionpack/test/abstract/views/helper_test.erb b/actionpack/test/abstract/views/helper_test.erb
deleted file mode 100644
index 8ae45cc195..0000000000
--- a/actionpack/test/abstract/views/helper_test.erb
+++ /dev/null
@@ -1 +0,0 @@
-Hello <%= helpery_test %> : <%= included_method %>
\ No newline at end of file
diff --git a/actionpack/test/abstract/views/index.erb b/actionpack/test/abstract/views/index.erb
deleted file mode 100644
index cc1a8b8c85..0000000000
--- a/actionpack/test/abstract/views/index.erb
+++ /dev/null
@@ -1 +0,0 @@
-Hello from index.erb
\ No newline at end of file
diff --git a/actionpack/test/abstract/views/layouts/abstract_controller/testing/me4.erb b/actionpack/test/abstract/views/layouts/abstract_controller/testing/me4.erb
deleted file mode 100644
index 172dd56569..0000000000
--- a/actionpack/test/abstract/views/layouts/abstract_controller/testing/me4.erb
+++ /dev/null
@@ -1 +0,0 @@
-Me4 Enter : <%= yield %> : Exit
\ No newline at end of file
diff --git a/actionpack/test/abstract/views/layouts/application.erb b/actionpack/test/abstract/views/layouts/application.erb
deleted file mode 100644
index 27317140ad..0000000000
--- a/actionpack/test/abstract/views/layouts/application.erb
+++ /dev/null
@@ -1 +0,0 @@
-Application Enter : <%= yield %> : Exit
\ No newline at end of file
diff --git a/actionpack/test/abstract/views/naked_render.erb b/actionpack/test/abstract/views/naked_render.erb
deleted file mode 100644
index 1b3d03878b..0000000000
--- a/actionpack/test/abstract/views/naked_render.erb
+++ /dev/null
@@ -1 +0,0 @@
-Hello from naked_render.erb
\ No newline at end of file
diff --git a/actionpack/test/abstract_unit.rb b/actionpack/test/abstract_unit.rb
index 8213997f4e..37e993b4e5 100644
--- a/actionpack/test/abstract_unit.rb
+++ b/actionpack/test/abstract_unit.rb
@@ -43,6 +43,9 @@ Thread.abort_on_exception = true
 # Show backtraces for deprecated behavior for quicker cleanup.
 ActiveSupport::Deprecation.debug = true
 
+# Disable available locale checks to avoid warnings running the test suite.
+I18n.enforce_available_locales = false
+
 # Register danish language for testing
 I18n.backend.store_translations 'da', {}
 I18n.backend.store_translations 'pt-BR', {}
@@ -64,28 +67,6 @@ module RackTestUtils
   extend self
 end
 
-module RenderERBUtils
-  def view
-    @view ||= begin
-      path = ActionView::FileSystemResolver.new(FIXTURE_LOAD_PATH)
-      view_paths = ActionView::PathSet.new([path])
-      ActionView::Base.new(view_paths)
-    end
-  end
-
-  def render_erb(string)
-    @virtual_path = nil
-
-    template = ActionView::Template.new(
-      string.strip,
-      "test template",
-      ActionView::Template::Handlers::ERB,
-      {})
-
-    template.render(self, {}).strip
-  end
-end
-
 SharedTestRoutes = ActionDispatch::Routing::RouteSet.new
 
 module ActionDispatch
@@ -290,15 +271,8 @@ module ActionController
   end
 end
 
-class ::ApplicationController < ActionController::Base
-end
 
-module ActionView
-  class TestCase
-    # Must repeat the setup because AV::TestCase is a duplication
-    # of AC::TestCase
-    include ActionDispatch::SharedRoutes
-  end
+class ::ApplicationController < ActionController::Base
 end
 
 class Workshop
@@ -360,7 +334,6 @@ class ThreadsController  < ResourcesController; end
 class MessagesController < ResourcesController; end
 class CommentsController < ResourcesController; end
 class ReviewsController < ResourcesController; end
-class AuthorsController < ResourcesController; end
 class LogosController < ResourcesController; end
 
 class AccountsController <  ResourcesController; end
@@ -371,8 +344,6 @@ class PreferencesController < ResourcesController; end
 
 module Backoffice
   class ProductsController < ResourcesController; end
-  class TagsController < ResourcesController; end
-  class ManufacturersController < ResourcesController; end
   class ImagesController < ResourcesController; end
 
   module Admin
diff --git a/actionpack/test/active_record_unit.rb b/actionpack/test/active_record_unit.rb
deleted file mode 100644
index 95fbb112c0..0000000000
--- a/actionpack/test/active_record_unit.rb
+++ /dev/null
@@ -1,91 +0,0 @@
-require 'abstract_unit'
-
-# Define the essentials
-class ActiveRecordTestConnector
-  cattr_accessor :able_to_connect
-  cattr_accessor :connected
-
-  # Set our defaults
-  self.connected = false
-  self.able_to_connect = true
-end
-
-# Try to grab AR
-unless defined?(ActiveRecord) && defined?(FixtureSet)
-  begin
-    PATH_TO_AR = "#{File.dirname(__FILE__)}/../../activerecord/lib"
-    raise LoadError, "#{PATH_TO_AR} doesn't exist" unless File.directory?(PATH_TO_AR)
-    $LOAD_PATH.unshift PATH_TO_AR
-    require 'active_record'
-  rescue LoadError => e
-    $stderr.print "Failed to load Active Record. Skipping Active Record assertion tests: #{e}"
-    ActiveRecordTestConnector.able_to_connect = false
-  end
-end
-$stderr.flush
-
-
-# Define the rest of the connector
-class ActiveRecordTestConnector
-  class << self
-    def setup
-      unless self.connected || !self.able_to_connect
-        setup_connection
-        load_schema
-        require_fixture_models
-        self.connected = true
-      end
-    rescue Exception => e  # errors from ActiveRecord setup
-      $stderr.puts "\nSkipping ActiveRecord assertion tests: #{e}"
-      #$stderr.puts "  #{e.backtrace.join("\n  ")}\n"
-      self.able_to_connect = false
-    end
-
-    private
-      def setup_connection
-        if Object.const_defined?(:ActiveRecord)
-          defaults = { :database => ':memory:' }
-          adapter = defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'
-          options = defaults.merge :adapter => adapter, :timeout => 500
-          ActiveRecord::Base.establish_connection(options)
-          ActiveRecord::Base.configurations = { 'sqlite3_ar_integration' => options }
-          ActiveRecord::Base.connection
-
-          Object.send(:const_set, :QUOTED_TYPE, ActiveRecord::Base.connection.quote_column_name('type')) unless Object.const_defined?(:QUOTED_TYPE)
-        else
-          raise "Can't setup connection since ActiveRecord isn't loaded."
-        end
-      end
-
-      # Load actionpack sqlite tables
-      def load_schema
-        File.read(File.dirname(__FILE__) + "/fixtures/db_definitions/sqlite.sql").split(';').each do |sql|
-          ActiveRecord::Base.connection.execute(sql) unless sql.blank?
-        end
-      end
-
-      def require_fixture_models
-        Dir.glob(File.dirname(__FILE__) + "/fixtures/*.rb").each {|f| require f}
-      end
-  end
-end
-
-class ActiveRecordTestCase < ActionController::TestCase
-  include ActiveRecord::TestFixtures
-
-  # Set our fixture path
-  if ActiveRecordTestConnector.able_to_connect
-    self.fixture_path = [FIXTURE_LOAD_PATH]
-    self.use_transactional_fixtures = false
-  end
-
-  def self.fixtures(*args)
-    super if ActiveRecordTestConnector.connected
-  end
-
-  def run(*args)
-    super if ActiveRecordTestConnector.connected
-  end
-end
-
-ActiveRecordTestConnector.setup
diff --git a/actionpack/test/activerecord/controller_runtime_test.rb b/actionpack/test/activerecord/controller_runtime_test.rb
deleted file mode 100644
index 368bec1c70..0000000000
--- a/actionpack/test/activerecord/controller_runtime_test.rb
+++ /dev/null
@@ -1,95 +0,0 @@
-require 'active_record_unit'
-require 'active_record/railties/controller_runtime'
-require 'fixtures/project'
-require 'active_support/log_subscriber/test_helper'
-require 'action_controller/log_subscriber'
-
-ActionController::Base.send :include, ActiveRecord::Railties::ControllerRuntime
-
-class ControllerRuntimeLogSubscriberTest < ActionController::TestCase
-  class LogSubscriberController < ActionController::Base
-    respond_to :html
-
-    def show
-      render :inline => "<%= Project.all %>"
-    end
-
-    def zero
-      render :inline => "Zero DB runtime"
-    end
-
-    def create
-      ActiveRecord::LogSubscriber.runtime += 100
-      project = Project.last
-      respond_with(project, location: url_for(action: :show))
-    end
-
-    def redirect
-      Project.all
-      redirect_to :action => 'show'
-    end
-
-    def db_after_render
-      render :inline => "Hello world"
-      Project.all
-      ActiveRecord::LogSubscriber.runtime += 100
-    end
-  end
-
-  include ActiveSupport::LogSubscriber::TestHelper
-  tests LogSubscriberController
-
-  def setup
-    super
-    @old_logger = ActionController::Base.logger
-    ActionController::LogSubscriber.attach_to :action_controller
-  end
-
-  def teardown
-    super
-    ActiveSupport::LogSubscriber.log_subscribers.clear
-    ActionController::Base.logger = @old_logger
-  end
-
-  def set_logger(logger)
-    ActionController::Base.logger = logger
-  end
-
-  def test_log_with_active_record
-    get :show
-    wait
-
-    assert_equal 2, @logger.logged(:info).size
-    assert_match(/\(Views: [\d.]+ms \| ActiveRecord: [\d.]+ms\)/, @logger.logged(:info)[1])
-  end
-
-  def test_runtime_reset_before_requests
-    ActiveRecord::LogSubscriber.runtime += 12345
-    get :zero
-    wait
-
-    assert_equal 2, @logger.logged(:info).size
-    assert_match(/\(Views: [\d.]+ms \| ActiveRecord: 0.0ms\)/, @logger.logged(:info)[1])
-  end
-
-  def test_log_with_active_record_when_post
-    post :create
-    wait
-    assert_match(/ActiveRecord: ([1-9][\d.]+)ms\)/, @logger.logged(:info)[2])
-  end
-
-  def test_log_with_active_record_when_redirecting
-    get :redirect
-    wait
-    assert_equal 3, @logger.logged(:info).size
-    assert_match(/\(ActiveRecord: [\d.]+ms\)/, @logger.logged(:info)[2])
-  end
-
-  def test_include_time_query_time_after_rendering
-    get :db_after_render
-    wait
-
-    assert_equal 2, @logger.logged(:info).size
-    assert_match(/\(Views: [\d.]+ms \| ActiveRecord: ([1-9][\d.]+)ms\)/, @logger.logged(:info)[1])
-  end
-end
diff --git a/actionpack/test/activerecord/form_helper_activerecord_test.rb b/actionpack/test/activerecord/form_helper_activerecord_test.rb
deleted file mode 100644
index 2e302c65a7..0000000000
--- a/actionpack/test/activerecord/form_helper_activerecord_test.rb
+++ /dev/null
@@ -1,91 +0,0 @@
-require 'active_record_unit'
-require 'fixtures/project'
-require 'fixtures/developer'
-
-class FormHelperActiveRecordTest < ActionView::TestCase
-  tests ActionView::Helpers::FormHelper
-
-  def form_for(*)
-    @output_buffer = super
-  end
-
-  def setup
-    @developer = Developer.new
-    @developer.id   = 123
-    @developer.name = "developer #123"
-
-    @project = Project.new
-    @project.id   = 321
-    @project.name = "project #321"
-    @project.save
-
-    @developer.projects << @project
-    @developer.save
-  end
-
-  def teardown
-    Project.delete(321)
-    Developer.delete(123)
-  end
-
-  Routes = ActionDispatch::Routing::RouteSet.new
-  Routes.draw do
-    resources :developers do
-      resources :projects
-    end
-  end
-
-  def _routes
-    Routes
-  end
-
-  include Routes.url_helpers
-
-  def test_nested_fields_for_with_child_index_option_override_on_a_nested_attributes_collection_association
-    form_for(@developer) do |f|
-      concat f.fields_for(:projects, @developer.projects.first, :child_index => 'abc') { |cf|
-        concat cf.text_field(:name)
-      }
-    end
-
-    expected = whole_form('/developers/123', 'edit_developer_123', 'edit_developer', :method => 'patch') do
-      '<input id="developer_projects_attributes_abc_name" name="developer[projects_attributes][abc][name]" type="text" value="project #321" />' +
-          '<input id="developer_projects_attributes_abc_id" name="developer[projects_attributes][abc][id]" type="hidden" value="321" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  protected
-
-  def hidden_fields(method = nil)
-    txt =  %{<div style="margin:0;padding:0;display:inline">}
-    txt << %{<input name="utf8" type="hidden" value="&#x2713;" />}
-    if method && !%w(get post).include?(method.to_s)
-      txt << %{<input name="_method" type="hidden" value="#{method}" />}
-    end
-    txt << %{</div>}
-  end
-
-  def form_text(action = "/", id = nil, html_class = nil, remote = nil, multipart = nil, method = nil)
-    txt =  %{<form accept-charset="UTF-8" action="#{action}"}
-    txt << %{ enctype="multipart/form-data"} if multipart
-    txt << %{ data-remote="true"} if remote
-    txt << %{ class="#{html_class}"} if html_class
-    txt << %{ id="#{id}"} if id
-    method = method.to_s == "get" ? "get" : "post"
-    txt << %{ method="#{method}">}
-  end
-
-  def whole_form(action = "/", id = nil, html_class = nil, options = nil)
-    contents = block_given? ? yield : ""
-
-    if options.is_a?(Hash)
-      method, remote, multipart = options.values_at(:method, :remote, :multipart)
-    else
-      method = options
-    end
-
-    form_text(action, id, html_class, remote, multipart, method) + hidden_fields(method) + contents + "</form>"
-  end
-end
\ No newline at end of file
diff --git a/actionpack/test/activerecord/polymorphic_routes_test.rb b/actionpack/test/activerecord/polymorphic_routes_test.rb
deleted file mode 100644
index afb714484b..0000000000
--- a/actionpack/test/activerecord/polymorphic_routes_test.rb
+++ /dev/null
@@ -1,546 +0,0 @@
-require 'active_record_unit'
-require 'fixtures/project'
-
-class Task < ActiveRecord::Base
-  self.table_name = 'projects'
-end
-
-class Step < ActiveRecord::Base
-  self.table_name = 'projects'
-end
-
-class Bid < ActiveRecord::Base
-  self.table_name = 'projects'
-end
-
-class Tax < ActiveRecord::Base
-  self.table_name = 'projects'
-end
-
-class Fax < ActiveRecord::Base
-  self.table_name = 'projects'
-end
-
-class Series < ActiveRecord::Base
-  self.table_name = 'projects'
-end
-
-class ModelDelegator < ActiveRecord::Base
-  self.table_name = 'projects'
-
-  def to_model
-    ModelDelegate.new
-  end
-end
-
-class ModelDelegate
-  def self.model_name
-    ActiveModel::Name.new(self)
-  end
-
-  def to_param
-    'overridden'
-  end
-end
-
-module Blog
-  class Post < ActiveRecord::Base
-    self.table_name = 'projects'
-  end
-
-  class Blog < ActiveRecord::Base
-    self.table_name = 'projects'
-  end
-
-  def self.use_relative_model_naming?
-    true
-  end
-end
-
-class PolymorphicRoutesTest < ActionController::TestCase
-  include SharedTestRoutes.url_helpers
-  self.default_url_options[:host] = 'example.com'
-
-  def setup
-    @project = Project.new
-    @task = Task.new
-    @step = Step.new
-    @bid = Bid.new
-    @tax = Tax.new
-    @fax = Fax.new
-    @delegator = ModelDelegator.new
-    @series = Series.new
-    @blog_post = Blog::Post.new
-    @blog_blog = Blog::Blog.new
-  end
-
-  def test_passing_routes_proxy
-    with_namespaced_routes(:blog) do
-      proxy = ActionDispatch::Routing::RoutesProxy.new(_routes, self)
-      @blog_post.save
-      assert_equal "http://example.com/posts/#{@blog_post.id}", polymorphic_url([proxy, @blog_post])
-    end
-  end
-
-  def test_namespaced_model
-    with_namespaced_routes(:blog) do
-      @blog_post.save
-      assert_equal "http://example.com/posts/#{@blog_post.id}", polymorphic_url(@blog_post)
-    end
-  end
-
-  def test_namespaced_model_with_name_the_same_as_namespace
-    with_namespaced_routes(:blog) do
-      @blog_blog.save
-      assert_equal "http://example.com/blogs/#{@blog_blog.id}", polymorphic_url(@blog_blog)
-    end
-  end
-
-  def test_namespaced_model_with_nested_resources
-    with_namespaced_routes(:blog) do
-      @blog_post.save
-      @blog_blog.save
-      assert_equal "http://example.com/blogs/#{@blog_blog.id}/posts/#{@blog_post.id}", polymorphic_url([@blog_blog, @blog_post])
-    end
-  end
-
-  def test_with_nil
-    with_test_routes do
-      assert_raise ArgumentError, "Nil location provided. Can't build URI." do
-        polymorphic_url(nil)
-      end
-    end
-  end
-
-  def test_with_record
-    with_test_routes do
-      @project.save
-      assert_equal "http://example.com/projects/#{@project.id}", polymorphic_url(@project)
-    end
-  end
-
-  def test_with_class
-    with_test_routes do
-      assert_equal "http://example.com/projects", polymorphic_url(@project.class)
-    end
-  end
-
-  def test_with_new_record
-    with_test_routes do
-      assert_equal "http://example.com/projects", polymorphic_url(@project)
-    end
-  end
-
-  def test_with_destroyed_record
-    with_test_routes do
-      @project.destroy
-      assert_equal "http://example.com/projects", polymorphic_url(@project)
-    end
-  end
-
-  def test_with_record_and_action
-    with_test_routes do
-      assert_equal "http://example.com/projects/new", polymorphic_url(@project, :action => 'new')
-    end
-  end
-
-  def test_url_helper_prefixed_with_new
-    with_test_routes do
-      assert_equal "http://example.com/projects/new", new_polymorphic_url(@project)
-    end
-  end
-
-  def test_url_helper_prefixed_with_edit
-    with_test_routes do
-      @project.save
-      assert_equal "http://example.com/projects/#{@project.id}/edit", edit_polymorphic_url(@project)
-    end
-  end
-
-  def test_url_helper_prefixed_with_edit_with_url_options
-    with_test_routes do
-      @project.save
-      assert_equal "http://example.com/projects/#{@project.id}/edit?param1=10", edit_polymorphic_url(@project, :param1 => '10')
-    end
-  end
-
-  def test_url_helper_with_url_options
-    with_test_routes do
-      @project.save
-      assert_equal "http://example.com/projects/#{@project.id}?param1=10", polymorphic_url(@project, :param1 => '10')
-    end
-  end
-
-  def test_format_option
-    with_test_routes do
-      @project.save
-      assert_equal "http://example.com/projects/#{@project.id}.pdf", polymorphic_url(@project, :format => :pdf)
-    end
-  end
-
-  def test_format_option_with_url_options
-    with_test_routes do
-      @project.save
-      assert_equal "http://example.com/projects/#{@project.id}.pdf?param1=10", polymorphic_url(@project, :format => :pdf, :param1 => '10')
-    end
-  end
-
-  def test_id_and_format_option
-    with_test_routes do
-      @project.save
-      assert_equal "http://example.com/projects/#{@project.id}.pdf", polymorphic_url(:id => @project, :format => :pdf)
-    end
-  end
-
-  def test_with_nested
-    with_test_routes do
-      @project.save
-      @task.save
-      assert_equal "http://example.com/projects/#{@project.id}/tasks/#{@task.id}", polymorphic_url([@project, @task])
-    end
-  end
-
-  def test_with_nested_unsaved
-    with_test_routes do
-      @project.save
-      assert_equal "http://example.com/projects/#{@project.id}/tasks", polymorphic_url([@project, @task])
-    end
-  end
-
-  def test_with_nested_destroyed
-    with_test_routes do
-      @project.save
-      @task.destroy
-      assert_equal "http://example.com/projects/#{@project.id}/tasks", polymorphic_url([@project, @task])
-    end
-  end
-
-  def test_with_nested_class
-    with_test_routes do
-      @project.save
-      assert_equal "http://example.com/projects/#{@project.id}/tasks", polymorphic_url([@project, @task.class])
-    end
-  end
-
-  def test_class_with_array_and_namespace
-    with_admin_test_routes do
-      assert_equal "http://example.com/admin/projects", polymorphic_url([:admin, @project.class])
-    end
-  end
-
-  def test_new_with_array_and_namespace
-    with_admin_test_routes do
-      assert_equal "http://example.com/admin/projects/new", polymorphic_url([:admin, @project], :action => 'new')
-    end
-  end
-
-  def test_unsaved_with_array_and_namespace
-    with_admin_test_routes do
-      assert_equal "http://example.com/admin/projects", polymorphic_url([:admin, @project])
-    end
-  end
-
-  def test_nested_unsaved_with_array_and_namespace
-    with_admin_test_routes do
-      @project.save
-      assert_equal "http://example.com/admin/projects/#{@project.id}/tasks", polymorphic_url([:admin, @project, @task])
-    end
-  end
-
-  def test_nested_with_array_and_namespace
-    with_admin_test_routes do
-      @project.save
-      @task.save
-      assert_equal "http://example.com/admin/projects/#{@project.id}/tasks/#{@task.id}", polymorphic_url([:admin, @project, @task])
-    end
-  end
-
-  def test_ordering_of_nesting_and_namespace
-    with_admin_and_site_test_routes do
-      @project.save
-      @task.save
-      @step.save
-      assert_equal "http://example.com/admin/projects/#{@project.id}/site/tasks/#{@task.id}/steps/#{@step.id}", polymorphic_url([:admin, @project, :site, @task, @step])
-    end
-  end
-
-  def test_nesting_with_array_ending_in_singleton_resource
-    with_test_routes do
-      @project.save
-      assert_equal "http://example.com/projects/#{@project.id}/bid", polymorphic_url([@project, :bid])
-    end
-  end
-
-  def test_nesting_with_array_containing_singleton_resource
-    with_test_routes do
-      @project.save
-      @task.save
-      assert_equal "http://example.com/projects/#{@project.id}/bid/tasks/#{@task.id}", polymorphic_url([@project, :bid, @task])
-    end
-  end
-
-  def test_nesting_with_array_containing_singleton_resource_and_format
-    with_test_routes do
-      @project.save
-      @task.save
-      assert_equal "http://example.com/projects/#{@project.id}/bid/tasks/#{@task.id}.pdf", polymorphic_url([@project, :bid, @task], :format => :pdf)
-    end
-  end
-
-  def test_nesting_with_array_containing_namespace_and_singleton_resource
-    with_admin_test_routes do
-      @project.save
-      @task.save
-      assert_equal "http://example.com/admin/projects/#{@project.id}/bid/tasks/#{@task.id}", polymorphic_url([:admin, @project, :bid, @task])
-    end
-  end
-
-  def test_nesting_with_array_containing_nil
-    with_test_routes do
-      @project.save
-      assert_equal "http://example.com/projects/#{@project.id}/bid", polymorphic_url([@project, nil, :bid])
-    end
-  end
-
-  def test_with_array_containing_single_object
-    with_test_routes do
-      @project.save
-      assert_equal "http://example.com/projects/#{@project.id}", polymorphic_url([nil, @project])
-    end
-  end
-
-  def test_with_array_containing_single_name
-    with_test_routes do
-      @project.save
-      assert_equal "http://example.com/projects", polymorphic_url([:projects])
-    end
-  end
-
-  def test_with_array_containing_symbols
-    with_test_routes do
-      assert_equal "http://example.com/series/new", polymorphic_url([:new, :series])
-    end
-  end
-
-  def test_with_hash
-    with_test_routes do
-      @project.save
-      assert_equal "http://example.com/projects/#{@project.id}", polymorphic_url(:id => @project)
-    end
-  end
-
-  def test_polymorphic_path_accepts_options
-    with_test_routes do
-      assert_equal "/projects/new", polymorphic_path(@project, :action => 'new')
-    end
-  end
-
-  def test_polymorphic_path_does_not_modify_arguments
-    with_admin_test_routes do
-      @project.save
-      @task.save
-
-      options = {}
-      object_array = [:admin, @project, @task]
-      original_args = [object_array.dup, options.dup]
-
-      assert_no_difference('object_array.size') { polymorphic_path(object_array, options) }
-      assert_equal original_args, [object_array, options]
-    end
-  end
-
-  # Tests for names where .plural.singular doesn't round-trip
-  def test_with_irregular_plural_record
-    with_test_routes do
-      @tax.save
-      assert_equal "http://example.com/taxes/#{@tax.id}", polymorphic_url(@tax)
-    end
-  end
-
-  def test_with_irregular_plural_class
-    with_test_routes do
-      assert_equal "http://example.com/taxes", polymorphic_url(@tax.class)
-    end
-  end
-
-  def test_with_irregular_plural_new_record
-    with_test_routes do
-      assert_equal "http://example.com/taxes", polymorphic_url(@tax)
-    end
-  end
-
-  def test_with_irregular_plural_destroyed_record
-    with_test_routes do
-      @tax.destroy
-      assert_equal "http://example.com/taxes", polymorphic_url(@tax)
-    end
-  end
-
-  def test_with_irregular_plural_record_and_action
-    with_test_routes do
-      assert_equal "http://example.com/taxes/new", polymorphic_url(@tax, :action => 'new')
-    end
-  end
-
-  def test_irregular_plural_url_helper_prefixed_with_new
-    with_test_routes do
-      assert_equal "http://example.com/taxes/new", new_polymorphic_url(@tax)
-    end
-  end
-
-  def test_irregular_plural_url_helper_prefixed_with_edit
-    with_test_routes do
-      @tax.save
-      assert_equal "http://example.com/taxes/#{@tax.id}/edit", edit_polymorphic_url(@tax)
-    end
-  end
-
-  def test_with_nested_irregular_plurals
-    with_test_routes do
-      @tax.save
-      @fax.save
-      assert_equal "http://example.com/taxes/#{@tax.id}/faxes/#{@fax.id}", polymorphic_url([@tax, @fax])
-    end
-  end
-
-  def test_with_nested_unsaved_irregular_plurals
-    with_test_routes do
-      @tax.save
-      assert_equal "http://example.com/taxes/#{@tax.id}/faxes", polymorphic_url([@tax, @fax])
-    end
-  end
-
-  def test_new_with_irregular_plural_array_and_namespace
-    with_admin_test_routes do
-      assert_equal "http://example.com/admin/taxes/new", polymorphic_url([:admin, @tax], :action => 'new')
-    end
-  end
-
-  def test_class_with_irregular_plural_array_and_namespace
-    with_admin_test_routes do
-      assert_equal "http://example.com/admin/taxes", polymorphic_url([:admin, @tax.class])
-    end
-  end
-
-  def test_unsaved_with_irregular_plural_array_and_namespace
-    with_admin_test_routes do
-      assert_equal "http://example.com/admin/taxes", polymorphic_url([:admin, @tax])
-    end
-  end
-
-  def test_nesting_with_irregular_plurals_and_array_ending_in_singleton_resource
-    with_test_routes do
-      @tax.save
-      assert_equal "http://example.com/taxes/#{@tax.id}/bid", polymorphic_url([@tax, :bid])
-    end
-  end
-
-  def test_with_array_containing_single_irregular_plural_object
-    with_test_routes do
-      @tax.save
-      assert_equal "http://example.com/taxes/#{@tax.id}", polymorphic_url([nil, @tax])
-    end
-  end
-
-  def test_with_array_containing_single_name_irregular_plural
-    with_test_routes do
-      @tax.save
-      assert_equal "http://example.com/taxes", polymorphic_url([:taxes])
-    end
-  end
-
- # Tests for uncountable names
-  def test_uncountable_resource
-    with_test_routes do
-      @series.save
-      assert_equal "http://example.com/series/#{@series.id}", polymorphic_url(@series)
-      assert_equal "http://example.com/series", polymorphic_url(Series.new)
-    end
-  end
-
-  def test_routing_a_to_model_delegate
-    with_test_routes do
-      @delegator.save
-      assert_equal "http://example.com/model_delegates/overridden", polymorphic_url(@delegator)
-    end
-  end
-
-  def with_namespaced_routes(name)
-    with_routing do |set|
-      set.draw do
-        scope(:module => name) do
-          resources :blogs do
-            resources :posts
-          end
-          resources :posts
-        end
-      end
-
-      self.class.send(:include, @routes.url_helpers)
-      yield
-    end
-  end
-
-  def with_test_routes(options = {})
-    with_routing do |set|
-      set.draw do
-        resources :projects do
-          resources :tasks
-          resource :bid do
-            resources :tasks
-          end
-        end
-        resources :taxes do
-          resources :faxes
-          resource :bid
-        end
-        resources :series
-        resources :model_delegates
-      end
-
-      self.class.send(:include, @routes.url_helpers)
-      yield
-    end
-  end
-
-  def with_admin_test_routes(options = {})
-    with_routing do |set|
-      set.draw do
-        namespace :admin do
-          resources :projects do
-            resources :tasks
-            resource :bid do
-              resources :tasks
-            end
-          end
-          resources :taxes do
-            resources :faxes
-          end
-          resources :series
-        end
-      end
-
-      self.class.send(:include, @routes.url_helpers)
-      yield
-    end
-  end
-
-  def with_admin_and_site_test_routes(options = {})
-    with_routing do |set|
-      set.draw do
-        namespace :admin do
-          resources :projects do
-            namespace :site do
-              resources :tasks do
-                resources :steps
-              end
-            end
-          end
-        end
-      end
-
-      self.class.send(:include, @routes.url_helpers)
-      yield
-    end
-  end
-end
diff --git a/actionpack/test/activerecord/render_partial_with_record_identification_test.rb b/actionpack/test/activerecord/render_partial_with_record_identification_test.rb
deleted file mode 100644
index 409370104d..0000000000
--- a/actionpack/test/activerecord/render_partial_with_record_identification_test.rb
+++ /dev/null
@@ -1,210 +0,0 @@
-require 'active_record_unit'
-
-class RenderPartialWithRecordIdentificationController < ActionController::Base
-  def render_with_has_many_and_belongs_to_association
-    @developer = Developer.find(1)
-    render :partial => @developer.projects
-  end
-
-  def render_with_has_many_association
-    @topic = Topic.find(1)
-    render :partial => @topic.replies
-  end
-
-  def render_with_scope
-    render :partial => Reply.base
-  end
-
-  def render_with_has_many_through_association
-    @developer = Developer.first
-    render :partial => @developer.topics
-  end
-
-  def render_with_has_one_association
-    @company = Company.find(1)
-    render :partial => @company.mascot
-  end
-
-  def render_with_belongs_to_association
-    @reply = Reply.find(1)
-    render :partial => @reply.topic
-  end
-
-  def render_with_record
-    @developer = Developer.first
-    render :partial => @developer
-  end
-
-  def render_with_record_collection
-    @developers = Developer.all
-    render :partial => @developers
-  end
-
-  def render_with_record_collection_and_spacer_template
-    @developer = Developer.find(1)
-    render :partial => @developer.projects, :spacer_template => 'test/partial_only'
-  end
-end
-
-class RenderPartialWithRecordIdentificationTest < ActiveRecordTestCase
-  tests RenderPartialWithRecordIdentificationController
-  fixtures :developers, :projects, :developers_projects, :topics, :replies, :companies, :mascots
-
-  def test_rendering_partial_with_has_many_and_belongs_to_association
-    get :render_with_has_many_and_belongs_to_association
-    assert_template 'projects/_project'
-    assert_equal assigns(:developer).projects.map(&:name).join, @response.body
-  end
-
-  def test_rendering_partial_with_has_many_association
-    get :render_with_has_many_association
-    assert_template 'replies/_reply'
-    assert_equal 'Birdman is better!', @response.body
-  end
-
-  def test_rendering_partial_with_scope
-    get :render_with_scope
-    assert_template 'replies/_reply'
-    assert_equal 'Birdman is better!Nuh uh!', @response.body
-  end
-
-  def test_render_with_record
-    get :render_with_record
-    assert_template 'developers/_developer'
-    assert_equal 'David', @response.body
-  end
-
-  def test_render_with_record_collection
-    get :render_with_record_collection
-    assert_template 'developers/_developer'
-    assert_equal 'DavidJamisfixture_3fixture_4fixture_5fixture_6fixture_7fixture_8fixture_9fixture_10Jamis', @response.body
-  end
-
-  def test_render_with_record_collection_and_spacer_template
-    get :render_with_record_collection_and_spacer_template
-    assert_equal assigns(:developer).projects.map(&:name).join('only partial'), @response.body
-  end
-
-  def test_rendering_partial_with_has_one_association
-    mascot = Company.find(1).mascot
-    get :render_with_has_one_association
-    assert_template 'mascots/_mascot'
-    assert_equal mascot.name, @response.body
-  end
-end
-
-class Game < Struct.new(:name, :id)
-  extend ActiveModel::Naming
-  include ActiveModel::Conversion
-  def to_param
-    id.to_s
-  end
-end
-
-module Fun
-  class NestedController < ActionController::Base
-    def render_with_record_in_nested_controller
-      render :partial => Game.new("Pong")
-    end
-
-    def render_with_record_collection_in_nested_controller
-      render :partial => [ Game.new("Pong"), Game.new("Tank") ]
-    end
-  end
-
-  module Serious
-    class NestedDeeperController < ActionController::Base
-      def render_with_record_in_deeper_nested_controller
-        render :partial => Game.new("Chess")
-      end
-
-      def render_with_record_collection_in_deeper_nested_controller
-        render :partial => [ Game.new("Chess"), Game.new("Sudoku"), Game.new("Solitaire") ]
-      end
-    end
-  end
-end
-
-class RenderPartialWithRecordIdentificationAndNestedControllersTest < ActiveRecordTestCase
-  tests Fun::NestedController
-
-  def test_render_with_record_in_nested_controller
-    get :render_with_record_in_nested_controller
-    assert_template %r{\Afun/games/_game\Z}
-    assert_equal "Fun Pong\n", @response.body
-  end
-
-  def test_render_with_record_collection_in_nested_controller
-    get :render_with_record_collection_in_nested_controller
-    assert_template %r{\Afun/games/_game\Z}
-    assert_equal "Fun Pong\nFun Tank\n", @response.body
-  end
-end
-
-class RenderPartialWithRecordIdentificationAndNestedControllersWithoutPrefixTest < ActiveRecordTestCase
-  tests Fun::NestedController
-
-  def test_render_with_record_in_nested_controller
-    old_config = ActionView::Base.prefix_partial_path_with_controller_namespace
-    ActionView::Base.prefix_partial_path_with_controller_namespace = false
-
-    get :render_with_record_in_nested_controller
-    assert_template %r{\Agames/_game\Z}
-    assert_equal "Just Pong\n", @response.body
-  ensure
-    ActionView::Base.prefix_partial_path_with_controller_namespace = old_config
-  end
-
-  def test_render_with_record_collection_in_nested_controller
-    old_config = ActionView::Base.prefix_partial_path_with_controller_namespace
-    ActionView::Base.prefix_partial_path_with_controller_namespace = false
-
-    get :render_with_record_collection_in_nested_controller
-    assert_template %r{\Agames/_game\Z}
-    assert_equal "Just Pong\nJust Tank\n", @response.body
-  ensure
-    ActionView::Base.prefix_partial_path_with_controller_namespace = old_config
-  end
-end
-
-class RenderPartialWithRecordIdentificationAndNestedDeeperControllersTest < ActiveRecordTestCase
-  tests Fun::Serious::NestedDeeperController
-
-  def test_render_with_record_in_deeper_nested_controller
-    get :render_with_record_in_deeper_nested_controller
-    assert_template %r{\Afun/serious/games/_game\Z}
-    assert_equal "Serious Chess\n", @response.body
-  end
-
-  def test_render_with_record_collection_in_deeper_nested_controller
-    get :render_with_record_collection_in_deeper_nested_controller
-    assert_template %r{\Afun/serious/games/_game\Z}
-    assert_equal "Serious Chess\nSerious Sudoku\nSerious Solitaire\n", @response.body
-  end
-end
-
-class RenderPartialWithRecordIdentificationAndNestedDeeperControllersWithoutPrefixTest < ActiveRecordTestCase
-  tests Fun::Serious::NestedDeeperController
-
-  def test_render_with_record_in_deeper_nested_controller
-    old_config = ActionView::Base.prefix_partial_path_with_controller_namespace
-    ActionView::Base.prefix_partial_path_with_controller_namespace = false
-
-    get :render_with_record_in_deeper_nested_controller
-    assert_template %r{\Agames/_game\Z}
-    assert_equal "Just Chess\n", @response.body
-  ensure
-    ActionView::Base.prefix_partial_path_with_controller_namespace = old_config
-  end
-
-  def test_render_with_record_collection_in_deeper_nested_controller
-    old_config = ActionView::Base.prefix_partial_path_with_controller_namespace
-    ActionView::Base.prefix_partial_path_with_controller_namespace = false
-
-    get :render_with_record_collection_in_deeper_nested_controller
-    assert_template %r{\Agames/_game\Z}
-    assert_equal "Just Chess\nJust Sudoku\nJust Solitaire\n", @response.body
-  ensure
-    ActionView::Base.prefix_partial_path_with_controller_namespace = old_config
-  end
-end
diff --git a/actionpack/test/assertions/response_assertions_test.rb b/actionpack/test/assertions/response_assertions_test.rb
index ca1d58765d..5e64cae7e2 100644
--- a/actionpack/test/assertions/response_assertions_test.rb
+++ b/actionpack/test/assertions/response_assertions_test.rb
@@ -19,7 +19,7 @@ module ActionDispatch
           @response = FakeResponse.new sym
           assert_response sym
 
-          assert_raises(MiniTest::Assertion) {
+          assert_raises(Minitest::Assertion) {
             assert_response :unauthorized
           }
         end
@@ -29,11 +29,11 @@ module ActionDispatch
         @response = FakeResponse.new 400
         assert_response 400
 
-        assert_raises(MiniTest::Assertion) {
+        assert_raises(Minitest::Assertion) {
           assert_response :unauthorized
         }
 
-        assert_raises(MiniTest::Assertion) {
+        assert_raises(Minitest::Assertion) {
           assert_response 500
         }
       end
@@ -42,14 +42,22 @@ module ActionDispatch
         @response = FakeResponse.new 401
         assert_response :unauthorized
 
-        assert_raises(MiniTest::Assertion) {
+        assert_raises(Minitest::Assertion) {
           assert_response :ok
         }
 
-        assert_raises(MiniTest::Assertion) {
+        assert_raises(Minitest::Assertion) {
           assert_response :success
         }
       end
+
+      def test_assert_response_sym_typo
+        @response = FakeResponse.new 200
+
+        assert_raises(ArgumentError) {
+          assert_response :succezz
+        }
+      end
     end
   end
 end
diff --git a/actionpack/test/controller/action_pack_assertions_test.rb b/actionpack/test/controller/action_pack_assertions_test.rb
index 22a410db94..b6b5a218cc 100644
--- a/actionpack/test/controller/action_pack_assertions_test.rb
+++ b/actionpack/test/controller/action_pack_assertions_test.rb
@@ -39,6 +39,8 @@ class ActionPackAssertionsController < ActionController::Base
 
   def redirect_external() redirect_to "http://www.rubyonrails.org"; end
 
+  def redirect_external_protocol_relative() redirect_to "//www.rubyonrails.org"; end
+
   def response404() head '404 AWOL' end
 
   def response500() head '500 Sorry' end
@@ -258,6 +260,19 @@ class ActionPackAssertionsControllerTest < ActionController::TestCase
     end
   end
 
+  def test_assert_redirect_failure_message_with_protocol_relative_url
+    begin
+      process :redirect_external_protocol_relative
+      assert_redirected_to "/foo"
+    rescue ActiveSupport::TestCase::Assertion => ex
+      assert_no_match(
+        /#{request.protocol}#{request.host}\/\/www.rubyonrails.org/,
+        ex.message,
+        'protocol relative url was incorrectly normalized'
+      )
+    end
+  end
+
   def test_template_objects_exist
     process :assign_this
     assert !@controller.instance_variable_defined?(:"@hi")
@@ -309,6 +324,9 @@ class ActionPackAssertionsControllerTest < ActionController::TestCase
 
     process :redirect_external
     assert_equal 'http://www.rubyonrails.org', @response.redirect_url
+
+    process :redirect_external_protocol_relative
+    assert_equal '//www.rubyonrails.org', @response.redirect_url
   end
 
   def test_no_redirect_url
@@ -426,22 +444,18 @@ class ActionPackAssertionsControllerTest < ActionController::TestCase
 
   def test_assert_response_uses_exception_message
     @controller = AssertResponseWithUnexpectedErrorController.new
-    get :index
+    e = assert_raise RuntimeError, 'Expected non-success response' do
+      get :index
+    end
     assert_response :success
-    flunk 'Expected non-success response'
-  rescue RuntimeError => e
-    assert e.message.include?('FAIL')
+    assert_includes 'FAIL', e.message
   end
 
   def test_assert_response_failure_response_with_no_exception
     @controller = AssertResponseWithUnexpectedErrorController.new
     get :show
-    assert_response :success
-    flunk 'Expected non-success response'
-  rescue ActiveSupport::TestCase::Assertion
-    # success
-  rescue
-    flunk "assert_response failed to handle failure response with missing, but optional, exception."
+    assert_response 500
+    assert_equal 'Boom', response.body
   end
 end
 
diff --git a/actionpack/test/controller/assert_select_test.rb b/actionpack/test/controller/assert_select_test.rb
index 3d667f0a2f..114bbf3c22 100644
--- a/actionpack/test/controller/assert_select_test.rb
+++ b/actionpack/test/controller/assert_select_test.rb
@@ -8,6 +8,9 @@ require 'abstract_unit'
 require 'controller/fake_controllers'
 
 require 'action_mailer'
+require 'action_view'
+
+ActionMailer::Base.send(:include, ActionView::Layouts)
 ActionMailer::Base.view_paths = FIXTURE_LOAD_PATH
 
 class AssertSelectTest < ActionController::TestCase
diff --git a/actionpack/test/controller/base_test.rb b/actionpack/test/controller/base_test.rb
index d4f18d55a6..b2bfdae174 100644
--- a/actionpack/test/controller/base_test.rb
+++ b/actionpack/test/controller/base_test.rb
@@ -61,10 +61,7 @@ class UrlOptionsController < ActionController::Base
   end
 end
 
-class RecordIdentifierController < ActionController::Base
-end
-
-class RecordIdentifierWithoutDeprecationController < ActionController::Base
+class RecordIdentifierIncludedController < ActionController::Base
   include ActionView::RecordIdentifier
 end
 
@@ -88,43 +85,20 @@ class ControllerClassTests < ActiveSupport::TestCase
     assert_equal 'contained_empty', Submodule::ContainedEmptyController.controller_name
   end
 
-  def test_record_identifier
-    assert_respond_to RecordIdentifierController.new, :dom_id
-    assert_respond_to RecordIdentifierController.new, :dom_class
-  end
-
-  def test_record_identifier_is_deprecated
-    record = Comment.new
-    record.save
-
-    dom_id = nil
-    assert_deprecated 'dom_id method will no longer' do
-      dom_id = RecordIdentifierController.new.dom_id(record)
-    end
-
-    assert_equal 'comment_1', dom_id
-
-    dom_class = nil
-    assert_deprecated 'dom_class method will no longer' do
-      dom_class = RecordIdentifierController.new.dom_class(record)
-    end
-    assert_equal 'comment', dom_class
-  end
-
   def test_no_deprecation_when_action_view_record_identifier_is_included
     record = Comment.new
     record.save
 
     dom_id = nil
     assert_not_deprecated do
-      dom_id = RecordIdentifierWithoutDeprecationController.new.dom_id(record)
+      dom_id = RecordIdentifierIncludedController.new.dom_id(record)
     end
 
     assert_equal 'comment_1', dom_id
 
     dom_class = nil
     assert_not_deprecated do
-      dom_class = RecordIdentifierWithoutDeprecationController.new.dom_class(record)
+      dom_class = RecordIdentifierIncludedController.new.dom_class(record)
     end
     assert_equal 'comment', dom_class
   end
diff --git a/actionpack/test/controller/caching_test.rb b/actionpack/test/controller/caching_test.rb
index ca86837a2c..57b45b8f7b 100644
--- a/actionpack/test/controller/caching_test.rb
+++ b/actionpack/test/controller/caching_test.rb
@@ -1,6 +1,5 @@
 require 'fileutils'
 require 'abstract_unit'
-require 'active_record_unit'
 
 CACHE_DIR = 'test_cache'
 # Don't change '/../temp/' cavalierly or you might hose something you don't want hosed
@@ -21,7 +20,7 @@ class FragmentCachingMetalTest < ActionController::TestCase
     @controller = FragmentCachingMetalTestController.new
     @controller.perform_caching = true
     @controller.cache_store = @store
-    @params = { controller: 'posts', action: 'index'}
+    @params = { controller: 'posts', action: 'index' }
     @request = ActionController::TestRequest.new
     @response = ActionController::TestResponse.new
     @controller.params = @params
@@ -41,7 +40,7 @@ class CachingController < ActionController::Base
 end
 
 class FragmentCachingTestController < CachingController
-  def some_action; end;
+  def some_action; end
 end
 
 class FragmentCachingTest < ActionController::TestCase
@@ -313,18 +312,3 @@ class ViewCacheDependencyTest < ActionController::TestCase
     assert_equal %w(trombone flute), HasDependenciesController.new.view_cache_dependencies
   end
 end
-
-class DeprecatedPageCacheExtensionTest < ActiveSupport::TestCase
-  def test_page_cache_extension_binds_default_static_extension
-    deprecation_behavior = ActiveSupport::Deprecation.behavior
-    ActiveSupport::Deprecation.behavior = :silence
-    old_extension = ActionController::Base.default_static_extension
-
-    ActionController::Base.page_cache_extension = '.rss'
-
-    assert_equal '.rss', ActionController::Base.default_static_extension
-  ensure
-    ActiveSupport::Deprecation.behavior = deprecation_behavior
-    ActionController::Base.default_static_extension = old_extension
-  end
-end
diff --git a/actionpack/test/controller/capture_test.rb b/actionpack/test/controller/capture_test.rb
deleted file mode 100644
index 72263156d9..0000000000
--- a/actionpack/test/controller/capture_test.rb
+++ /dev/null
@@ -1,79 +0,0 @@
-require 'abstract_unit'
-require 'active_support/logger'
-
-class CaptureController < ActionController::Base
-  def self.controller_name; "test"; end
-  def self.controller_path; "test"; end
-
-  def content_for
-    @title = nil
-    render :layout => "talk_from_action"
-  end
-
-  def content_for_with_parameter
-    @title = nil
-    render :layout => "talk_from_action"
-  end
-
-  def content_for_concatenated
-    @title = nil
-    render :layout => "talk_from_action"
-  end
-
-  def non_erb_block_content_for
-    @title = nil
-    render :layout => "talk_from_action"
-  end
-
-  def proper_block_detection
-    @todo = "some todo"
-  end
-end
-
-class CaptureTest < ActionController::TestCase
-  tests CaptureController
-
-  def setup
-    super
-    # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get
-    # a more accurate simulation of what happens in "real life".
-    @controller.logger = ActiveSupport::Logger.new(nil)
-
-    @request.host = "www.nextangle.com"
-  end
-
-  def test_simple_capture
-    get :capturing
-    assert_equal "Dreamy days", @response.body.strip
-  end
-
-  def test_content_for
-    get :content_for
-    assert_equal expected_content_for_output, @response.body
-  end
-
-  def test_should_concatentate_content_for
-    get :content_for_concatenated
-    assert_equal expected_content_for_output, @response.body
-  end
-
-  def test_should_set_content_for_with_parameter
-    get :content_for_with_parameter
-    assert_equal expected_content_for_output, @response.body
-  end
-
-  def test_non_erb_block_content_for
-    get :non_erb_block_content_for
-    assert_equal expected_content_for_output, @response.body
-  end
-
-  def test_proper_block_detection
-    get :proper_block_detection
-    assert_equal "some todo", @response.body
-  end
-
-  private
-    def expected_content_for_output
-      "<title>Putting stuff in the title!</title>\nGreat stuff!"
-    end
-end
diff --git a/actionpack/test/controller/filters_test.rb b/actionpack/test/controller/filters_test.rb
index 4c82625e8e..d3efca5b6f 100644
--- a/actionpack/test/controller/filters_test.rb
+++ b/actionpack/test/controller/filters_test.rb
@@ -208,6 +208,10 @@ class FilterTest < ActionController::TestCase
     before_filter(ConditionalClassFilter, :ensure_login, Proc.new {|c| c.instance_variable_set(:"@ran_proc_filter1", true)}, :except => :show_without_filter) { |c| c.instance_variable_set(:"@ran_proc_filter2", true)}
   end
 
+  class OnlyConditionalOptionsFilter < ConditionalFilterController
+    before_filter :ensure_login, :only => :index, :if => Proc.new {|c| c.instance_variable_set(:"@ran_conditional_index_proc", true) }
+  end
+
   class ConditionalOptionsFilter < ConditionalFilterController
     before_filter :ensure_login, :if => Proc.new { |c| true }
     before_filter :clean_up_tmp, :if => Proc.new { |c| false }
@@ -649,6 +653,11 @@ class FilterTest < ActionController::TestCase
     assert !assigns["ran_class_filter"]
   end
 
+  def test_running_only_condition_and_conditional_options
+    test_process(OnlyConditionalOptionsFilter, "show")
+    assert_not assigns["ran_conditional_index_proc"]
+  end
+
   def test_running_before_and_after_condition_filters
     test_process(BeforeAndAfterConditionController)
     assert_equal %w( ensure_login clean_up_tmp), assigns["ran_filter"]
@@ -884,17 +893,6 @@ class ControllerWithFilterInstance < PostsController
   around_filter YieldingFilter.new, :only => :raises_after
 end
 
-class ControllerWithFilterMethod < PostsController
-  class YieldingFilter < DefaultFilter
-    def around(controller)
-      yield
-      raise After
-    end
-  end
-
-  around_filter YieldingFilter.new.method(:around), :only => :raises_after
-end
-
 class ControllerWithProcFilter < PostsController
   around_filter(:only => :no_raise) do |c,b|
     c.instance_variable_set(:"@before", true)
diff --git a/actionpack/test/controller/flash_test.rb b/actionpack/test/controller/flash_test.rb
index 3b874a739a..9ceab91e42 100644
--- a/actionpack/test/controller/flash_test.rb
+++ b/actionpack/test/controller/flash_test.rb
@@ -174,12 +174,12 @@ class FlashTest < ActionController::TestCase
     flash.update(:foo => :foo_indeed, :bar => :bar_indeed)
 
     assert_equal(:foo_indeed, flash.discard(:foo)) # valid key passed
-    assert_nil flash.discard(:unknown) # non existant key passed
+    assert_nil flash.discard(:unknown) # non existent key passed
     assert_equal({:foo => :foo_indeed, :bar => :bar_indeed}, flash.discard().to_hash) # nothing passed
     assert_equal({:foo => :foo_indeed, :bar => :bar_indeed}, flash.discard(nil).to_hash) # nothing passed
 
     assert_equal(:foo_indeed, flash.keep(:foo)) # valid key passed
-    assert_nil flash.keep(:unknown) # non existant key passed
+    assert_nil flash.keep(:unknown) # non existent key passed
     assert_equal({:foo => :foo_indeed, :bar => :bar_indeed}, flash.keep().to_hash) # nothing passed
     assert_equal({:foo => :foo_indeed, :bar => :bar_indeed}, flash.keep(nil).to_hash) # nothing passed
   end
@@ -214,6 +214,18 @@ class FlashTest < ActionController::TestCase
     get :redirect_with_foo_flash
     assert_equal "for great justice", @controller.send(:flash)[:foo]
   end
+
+  class SubclassesTestController < TestController; end
+
+  def test_add_flash_type_to_subclasses
+    TestController.add_flash_types :foo
+    assert SubclassesTestController._flash_types.include?(:foo)
+  end
+
+  def test_do_not_add_flash_type_to_parent_class
+    SubclassesTestController.add_flash_types :bar
+    assert_not TestController._flash_types.include?(:bar)
+  end
 end
 
 class FlashIntegrationTest < ActionDispatch::IntegrationTest
diff --git a/actionpack/test/controller/helper_test.rb b/actionpack/test/controller/helper_test.rb
index 248c81193e..20f99f19ee 100644
--- a/actionpack/test/controller/helper_test.rb
+++ b/actionpack/test/controller/helper_test.rb
@@ -201,6 +201,12 @@ class HelperTest < ActiveSupport::TestCase
     # fun/pdf_helper.rb
     assert methods.include?(:foobar)
   end
+  
+  def test_helper_proxy_config
+    AllHelpersController.config.my_var = 'smth'
+    
+    assert_equal 'smth', AllHelpersController.helpers.config.my_var
+  end
 
   private
     def expected_helper_methods
diff --git a/actionpack/test/controller/http_digest_authentication_test.rb b/actionpack/test/controller/http_digest_authentication_test.rb
index 9f1c168209..52a0bc9aa3 100644
--- a/actionpack/test/controller/http_digest_authentication_test.rb
+++ b/actionpack/test/controller/http_digest_authentication_test.rb
@@ -21,7 +21,7 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
 
     def authenticate
       authenticate_or_request_with_http_digest("SuperSecret") do |username|
-        # Return the password
+        # Returns the password
         USERS[username]
       end
     end
diff --git a/actionpack/test/controller/integration_test.rb b/actionpack/test/controller/integration_test.rb
index f7ec6d71b3..e851cc6a63 100644
--- a/actionpack/test/controller/integration_test.rb
+++ b/actionpack/test/controller/integration_test.rb
@@ -277,7 +277,7 @@ class IntegrationProcessTest < ActionDispatch::IntegrationTest
     end
 
     def redirect
-      redirect_to :action => "get"
+      redirect_to action_url('get')
     end
   end
 
@@ -511,8 +511,8 @@ class IntegrationProcessTest < ActionDispatch::IntegrationTest
         end
 
         set.draw do
-          match ':action', :to => controller, :via => [:get, :post]
-          get 'get/:action', :to => controller
+          match ':action', :to => controller, :via => [:get, :post], :as => :action
+          get 'get/:action', :to => controller, :as => :get_action
         end
 
         self.singleton_class.send(:include, set.url_helpers)
diff --git a/actionpack/test/controller/layout_test.rb b/actionpack/test/controller/layout_test.rb
deleted file mode 100644
index 34304cf640..0000000000
--- a/actionpack/test/controller/layout_test.rb
+++ /dev/null
@@ -1,262 +0,0 @@
-require 'abstract_unit'
-require 'rbconfig'
-require 'active_support/core_ext/array/extract_options'
-
-# The view_paths array must be set on Base and not LayoutTest so that LayoutTest's inherited
-# method has access to the view_paths array when looking for a layout to automatically assign.
-old_load_paths = ActionController::Base.view_paths
-
-ActionView::Template::register_template_handler :mab,
-  lambda { |template| template.source.inspect }
-
-ActionController::Base.view_paths = [ File.dirname(__FILE__) + '/../fixtures/layout_tests/' ]
-
-class LayoutTest < ActionController::Base
-  def self.controller_path; 'views' end
-  def self._implied_layout_name; to_s.underscore.gsub(/_controller$/, '') ; end
-  self.view_paths = ActionController::Base.view_paths.dup
-end
-
-# Restore view_paths to previous value
-ActionController::Base.view_paths = old_load_paths
-
-class ProductController < LayoutTest
-end
-
-class ItemController < LayoutTest
-end
-
-class ThirdPartyTemplateLibraryController < LayoutTest
-end
-
-module ControllerNameSpace
-end
-
-class ControllerNameSpace::NestedController < LayoutTest
-end
-
-class MultipleExtensions < LayoutTest
-end
-
-class LayoutAutoDiscoveryTest < ActionController::TestCase
-  def setup
-    super
-    @request.host = "www.nextangle.com"
-  end
-
-  def test_application_layout_is_default_when_no_controller_match
-    @controller = ProductController.new
-    get :hello
-    assert_equal 'layout_test.erb hello.erb', @response.body
-  end
-
-  def test_controller_name_layout_name_match
-    @controller = ItemController.new
-    get :hello
-    assert_equal 'item.erb hello.erb', @response.body
-  end
-
-  def test_third_party_template_library_auto_discovers_layout
-    @controller = ThirdPartyTemplateLibraryController.new
-    get :hello
-    assert_response :success
-    assert_equal 'layouts/third_party_template_library.mab', @response.body
-  end
-
-  def test_namespaced_controllers_auto_detect_layouts1
-    @controller = ControllerNameSpace::NestedController.new
-    get :hello
-    assert_equal 'controller_name_space/nested.erb hello.erb', @response.body
-  end
-
-  def test_namespaced_controllers_auto_detect_layouts2
-    @controller = MultipleExtensions.new
-    get :hello
-    assert_equal 'multiple_extensions.html.erb hello.erb', @response.body.strip
-  end
-end
-
-class DefaultLayoutController < LayoutTest
-end
-
-class StreamingLayoutController < LayoutTest
-  def render(*args)
-    options = args.extract_options!
-    super(*args, options.merge(:stream => true))
-  end
-end
-
-class AbsolutePathLayoutController < LayoutTest
-  layout File.expand_path(File.expand_path(__FILE__) + '/../../fixtures/layout_tests/layouts/layout_test')
-end
-
-class HasOwnLayoutController < LayoutTest
-  layout 'item'
-end
-
-class HasNilLayoutSymbol < LayoutTest
-  layout :nilz
-
-  def nilz
-    nil
-  end
-end
-
-class HasNilLayoutProc < LayoutTest
-  layout proc { nil }
-end
-
-class PrependsViewPathController < LayoutTest
-  def hello
-    prepend_view_path File.dirname(__FILE__) + '/../fixtures/layout_tests/alt/'
-    render :layout => 'alt'
-  end
-end
-
-class OnlyLayoutController < LayoutTest
-  layout 'item', :only => "hello"
-end
-
-class ExceptLayoutController < LayoutTest
-  layout 'item', :except => "goodbye"
-end
-
-class SetsLayoutInRenderController < LayoutTest
-  def hello
-    render :layout => 'third_party_template_library'
-  end
-end
-
-class RendersNoLayoutController < LayoutTest
-  def hello
-    render :layout => false
-  end
-end
-
-class LayoutSetInResponseTest < ActionController::TestCase
-  include ActionView::Template::Handlers
-
-  def test_layout_set_when_using_default_layout
-    @controller = DefaultLayoutController.new
-    get :hello
-    assert_template :layout => "layouts/layout_test"
-  end
-
-  def test_layout_set_when_using_streaming_layout
-    @controller = StreamingLayoutController.new
-    get :hello
-    assert_template :hello
-  end
-
-  def test_layout_set_when_set_in_controller
-    @controller = HasOwnLayoutController.new
-    get :hello
-    assert_template :layout => "layouts/item"
-  end
-
-  def test_layout_symbol_set_in_controller_returning_nil_falls_back_to_default
-    @controller = HasNilLayoutSymbol.new
-    get :hello
-    assert_template layout: "layouts/layout_test"
-  end
-
-  def test_layout_proc_set_in_controller_returning_nil_falls_back_to_default
-    @controller = HasNilLayoutProc.new
-    get :hello
-    assert_template layout: "layouts/layout_test"
-  end
-
-  def test_layout_only_exception_when_included
-    @controller = OnlyLayoutController.new
-    get :hello
-    assert_template :layout => "layouts/item"
-  end
-
-  def test_layout_only_exception_when_excepted
-    @controller = OnlyLayoutController.new
-    get :goodbye
-    assert !@response.body.include?("item.erb"), "#{@response.body.inspect} included 'item.erb'"
-  end
-
-  def test_layout_except_exception_when_included
-    @controller = ExceptLayoutController.new
-    get :hello
-    assert_template :layout => "layouts/item"
-  end
-
-  def test_layout_except_exception_when_excepted
-    @controller = ExceptLayoutController.new
-    get :goodbye
-    assert !@response.body.include?("item.erb"), "#{@response.body.inspect} included 'item.erb'"
-  end
-
-  def test_layout_set_when_using_render
-    @controller = SetsLayoutInRenderController.new
-    get :hello
-    assert_template :layout => "layouts/third_party_template_library"
-  end
-
-  def test_layout_is_not_set_when_none_rendered
-    @controller = RendersNoLayoutController.new
-    get :hello
-    assert_template :layout => nil
-  end
-
-  def test_layout_is_picked_from_the_controller_instances_view_path
-    @controller = PrependsViewPathController.new
-    get :hello
-    assert_template :layout => /layouts\/alt/
-  end
-
-  def test_absolute_pathed_layout
-    @controller = AbsolutePathLayoutController.new
-    get :hello
-    assert_equal "layout_test.erb hello.erb", @response.body.strip
-  end
-end
-
-class RenderWithTemplateOptionController < LayoutTest
-  def hello
-    render :template => 'alt/hello'
-  end
-end
-
-class SetsNonExistentLayoutFile < LayoutTest
-  layout "nofile"
-end
-
-class LayoutExceptionRaisedTest < ActionController::TestCase
-  def test_exception_raised_when_layout_file_not_found
-    @controller = SetsNonExistentLayoutFile.new
-    assert_raise(ActionView::MissingTemplate) { get :hello }
-  end
-end
-
-class LayoutStatusIsRendered < LayoutTest
-  def hello
-    render :status => 401
-  end
-end
-
-class LayoutStatusIsRenderedTest < ActionController::TestCase
-  def test_layout_status_is_rendered
-    @controller = LayoutStatusIsRendered.new
-    get :hello
-    assert_response 401
-  end
-end
-
-unless RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
-  class LayoutSymlinkedTest < LayoutTest
-    layout "symlinked/symlinked_layout"
-  end
-
-  class LayoutSymlinkedIsRenderedTest < ActionController::TestCase
-    def test_symlinked_layout_is_rendered
-      @controller = LayoutSymlinkedTest.new
-      get :hello
-      assert_response 200
-      assert_template :layout => "layouts/symlinked/symlinked_layout"
-    end
-  end
-end
diff --git a/actionpack/test/controller/live_stream_test.rb b/actionpack/test/controller/live_stream_test.rb
index 34164a19f0..0a431270b5 100644
--- a/actionpack/test/controller/live_stream_test.rb
+++ b/actionpack/test/controller/live_stream_test.rb
@@ -2,6 +2,94 @@ require 'abstract_unit'
 require 'active_support/concurrency/latch'
 
 module ActionController
+  class SSETest < ActionController::TestCase
+    class SSETestController < ActionController::Base
+      include ActionController::Live
+
+      def basic_sse
+        response.headers['Content-Type'] = 'text/event-stream'
+        sse = SSE.new(response.stream)
+        sse.write("{\"name\":\"John\"}")
+        sse.write({ name: "Ryan" })
+      ensure
+        sse.close
+      end
+
+      def sse_with_event
+        sse = SSE.new(response.stream, event: "send-name")
+        sse.write("{\"name\":\"John\"}")
+        sse.write({ name: "Ryan" })
+      ensure
+        sse.close
+      end
+
+      def sse_with_retry
+        sse = SSE.new(response.stream, retry: 1000)
+        sse.write("{\"name\":\"John\"}")
+        sse.write({ name: "Ryan" }, retry: 1500)
+      ensure
+        sse.close
+      end
+
+      def sse_with_id
+        sse = SSE.new(response.stream)
+        sse.write("{\"name\":\"John\"}", id: 1)
+        sse.write({ name: "Ryan" }, id: 2)
+      ensure
+        sse.close
+      end
+    end
+
+    tests SSETestController
+
+    def wait_for_response_stream_close
+      while !response.stream.closed?
+        sleep 0.01
+      end
+    end
+
+    def test_basic_sse
+      get :basic_sse
+
+      wait_for_response_stream_close
+      assert_match(/data: {\"name\":\"John\"}/, response.body)
+      assert_match(/data: {\"name\":\"Ryan\"}/, response.body)
+    end
+
+    def test_sse_with_event_name
+      get :sse_with_event
+
+      wait_for_response_stream_close
+      assert_match(/data: {\"name\":\"John\"}/, response.body)
+      assert_match(/data: {\"name\":\"Ryan\"}/, response.body)
+      assert_match(/event: send-name/, response.body)
+    end
+
+    def test_sse_with_retry
+      get :sse_with_retry
+
+      wait_for_response_stream_close
+      first_response, second_response = response.body.split("\n\n")
+      assert_match(/data: {\"name\":\"John\"}/, first_response)
+      assert_match(/retry: 1000/, first_response)
+
+      assert_match(/data: {\"name\":\"Ryan\"}/, second_response)
+      assert_match(/retry: 1500/, second_response)
+    end
+
+    def test_sse_with_id
+      get :sse_with_id
+
+      wait_for_response_stream_close
+      first_response, second_response = response.body.split("\n\n")
+      assert_match(/data: {\"name\":\"John\"}/, first_response)
+      assert_match(/id: 1/, first_response)
+
+      assert_match(/data: {\"name\":\"Ryan\"}/, second_response)
+      assert_match(/id: 2/, second_response)
+    end
+  end
+
   class LiveStreamTest < ActionController::TestCase
     class TestController < ActionController::Base
       include ActionController::Live
@@ -135,7 +223,7 @@ module ActionController
 
       @controller.process :blocking_stream
 
-      assert t.join
+      assert t.join(3), 'timeout expired before the thread terminated'
     end
 
     def test_thread_locals_get_copied
diff --git a/actionpack/test/controller/localized_templates_test.rb b/actionpack/test/controller/localized_templates_test.rb
index 6b02eedaed..c95ef8a0c7 100644
--- a/actionpack/test/controller/localized_templates_test.rb
+++ b/actionpack/test/controller/localized_templates_test.rb
@@ -34,4 +34,15 @@ class LocalizedTemplatesTest < ActionController::TestCase
     get :hello_world
     assert_equal "Gutten Tag", @response.body
   end
+
+  def test_localized_template_has_correct_header_with_no_format_in_template_name
+    old_locale = I18n.locale
+    I18n.locale = :it
+
+    get :hello_world
+    assert_equal "Ciao Mondo", @response.body
+    assert_equal "text/html",  @response.content_type
+  ensure
+    I18n.locale = old_locale
+  end
 end
diff --git a/actionpack/test/controller/mime/accept_format_test.rb b/actionpack/test/controller/mime/accept_format_test.rb
new file mode 100644
index 0000000000..c03c7edeb8
--- /dev/null
+++ b/actionpack/test/controller/mime/accept_format_test.rb
@@ -0,0 +1,94 @@
+require 'abstract_unit'
+
+class StarStarMimeController < ActionController::Base
+  layout nil
+
+  def index
+    render
+  end
+end
+
+class StarStarMimeControllerTest < ActionController::TestCase
+  tests StarStarMimeController
+
+  def test_javascript_with_format
+    @request.accept = "text/javascript"
+    get :index, :format => 'js'
+    assert_match "function addition(a,b){ return a+b; }", @response.body
+  end
+
+  def test_javascript_with_no_format
+    @request.accept = "text/javascript"
+    get :index
+    assert_match "function addition(a,b){ return a+b; }", @response.body
+  end
+
+  def test_javascript_with_no_format_only_star_star
+    @request.accept = "*/*"
+    get :index
+    assert_match "function addition(a,b){ return a+b; }", @response.body
+  end
+end
+
+class AbstractPostController < ActionController::Base
+  self.view_paths = File.dirname(__FILE__) + "/../../fixtures/post_test/"
+end
+
+# For testing layouts which are set automatically
+class PostController < AbstractPostController
+  around_action :with_iphone
+
+  def index
+    respond_to(:html, :iphone, :js)
+  end
+
+protected
+
+  def with_iphone
+    request.format = "iphone" if request.env["HTTP_ACCEPT"] == "text/iphone"
+    yield
+  end
+end
+
+class SuperPostController < PostController
+end
+
+class MimeControllerLayoutsTest < ActionController::TestCase
+  tests PostController
+
+  def setup
+    super
+    @request.host = "www.example.com"
+    Mime::Type.register_alias("text/html", :iphone)
+  end
+
+  def teardown
+    super
+    Mime::Type.unregister(:iphone)
+  end
+
+  def test_missing_layout_renders_properly
+    get :index
+    assert_equal '<html><div id="html">Hello Firefox</div></html>', @response.body
+
+    @request.accept = "text/iphone"
+    get :index
+    assert_equal 'Hello iPhone', @response.body
+  end
+
+  def test_format_with_inherited_layouts
+    @controller = SuperPostController.new
+
+    get :index
+    assert_equal '<html><div id="html">Super Firefox</div></html>', @response.body
+
+    @request.accept = "text/iphone"
+    get :index
+    assert_equal '<html><div id="super_iphone">Super iPhone</div></html>', @response.body
+  end
+
+  def test_non_navigational_format_with_no_template_fallbacks_to_html_template_with_no_layout
+    get :index, :format => :js
+    assert_equal "Hello Firefox", @response.body
+  end
+end
diff --git a/actionpack/test/controller/mime/respond_to_test.rb b/actionpack/test/controller/mime/respond_to_test.rb
new file mode 100644
index 0000000000..84e4936f31
--- /dev/null
+++ b/actionpack/test/controller/mime/respond_to_test.rb
@@ -0,0 +1,743 @@
+require 'abstract_unit'
+
+class RespondToController < ActionController::Base
+  layout :set_layout
+
+  def html_xml_or_rss
+    respond_to do |type|
+      type.html { render :text => "HTML"    }
+      type.xml  { render :text => "XML"     }
+      type.rss  { render :text => "RSS"     }
+      type.all  { render :text => "Nothing" }
+    end
+  end
+
+  def js_or_html
+    respond_to do |type|
+      type.html { render :text => "HTML"    }
+      type.js   { render :text => "JS"      }
+      type.all  { render :text => "Nothing" }
+    end
+  end
+
+  def json_or_yaml
+    respond_to do |type|
+      type.json { render :text => "JSON" }
+      type.yaml { render :text => "YAML" }
+    end
+  end
+
+  def html_or_xml
+    respond_to do |type|
+      type.html { render :text => "HTML"    }
+      type.xml  { render :text => "XML"     }
+      type.all  { render :text => "Nothing" }
+    end
+  end
+
+  def json_xml_or_html
+    respond_to do |type|
+      type.json { render :text => 'JSON' }
+      type.xml { render :xml => 'XML' }
+      type.html { render :text => 'HTML' }
+    end
+  end
+
+
+  def forced_xml
+    request.format = :xml
+
+    respond_to do |type|
+      type.html { render :text => "HTML"    }
+      type.xml  { render :text => "XML"     }
+    end
+  end
+
+  def just_xml
+    respond_to do |type|
+      type.xml  { render :text => "XML" }
+    end
+  end
+
+  def using_defaults
+    respond_to do |type|
+      type.html
+      type.xml
+    end
+  end
+
+  def using_defaults_with_type_list
+    respond_to(:html, :xml)
+  end
+
+  def using_defaults_with_all
+    respond_to do |type|
+      type.html
+      type.all{ render text: "ALL" }
+    end
+  end
+
+  def made_for_content_type
+    respond_to do |type|
+      type.rss  { render :text => "RSS"  }
+      type.atom { render :text => "ATOM" }
+      type.all  { render :text => "Nothing" }
+    end
+  end
+
+  def custom_type_handling
+    respond_to do |type|
+      type.html { render :text => "HTML"    }
+      type.custom("application/crazy-xml")  { render :text => "Crazy XML"  }
+      type.all  { render :text => "Nothing" }
+    end
+  end
+
+
+  def custom_constant_handling
+    respond_to do |type|
+      type.html   { render :text => "HTML"   }
+      type.mobile { render :text => "Mobile" }
+    end
+  end
+
+  def custom_constant_handling_without_block
+    respond_to do |type|
+      type.html   { render :text => "HTML"   }
+      type.mobile
+    end
+  end
+
+  def handle_any
+    respond_to do |type|
+      type.html { render :text => "HTML" }
+      type.any(:js, :xml) { render :text => "Either JS or XML" }
+    end
+  end
+
+  def handle_any_any
+    respond_to do |type|
+      type.html { render :text => 'HTML' }
+      type.any { render :text => 'Whatever you ask for, I got it' }
+    end
+  end
+
+  def all_types_with_layout
+    respond_to do |type|
+      type.html
+    end
+  end
+
+  def iphone_with_html_response_type
+    request.format = :iphone if request.env["HTTP_ACCEPT"] == "text/iphone"
+
+    respond_to do |type|
+      type.html   { @type = "Firefox" }
+      type.iphone { @type = "iPhone"  }
+    end
+  end
+
+  def iphone_with_html_response_type_without_layout
+    request.format = "iphone" if request.env["HTTP_ACCEPT"] == "text/iphone"
+
+    respond_to do |type|
+      type.html   { @type = "Firefox"; render :action => "iphone_with_html_response_type" }
+      type.iphone { @type = "iPhone" ; render :action => "iphone_with_html_response_type" }
+    end
+  end
+
+  def variant_with_implicit_rendering
+  end
+
+  def variant_with_format_and_custom_render
+    request.variant = :mobile
+
+    respond_to do |type|
+      type.html { render text: "mobile" }
+    end
+  end
+
+  def multiple_variants_for_format
+    respond_to do |type|
+      type.html do |html|
+        html.tablet { render text: "tablet" }
+        html.phone  { render text: "phone" }
+      end
+    end
+  end
+
+  def variant_plus_none_for_format
+    respond_to do |format|
+      format.html do |variant|
+        variant.phone { render text: "phone" }
+        variant.none
+      end
+    end
+  end
+
+  def variant_inline_syntax
+    respond_to do |format|
+      format.js         { render text: "js"    }
+      format.html.none  { render text: "none"  }
+      format.html.phone { render text: "phone" }
+    end
+  end
+
+  def variant_inline_syntax_without_block
+    respond_to do |format|
+      format.js
+      format.html.none
+      format.html.phone
+    end
+  end
+
+  def variant_any
+    respond_to do |format|
+      format.html do |variant|
+        variant.any(:tablet, :phablet){ render text: "any" }
+        variant.phone { render text: "phone" }
+      end
+    end
+  end
+
+  def variant_any_any
+    respond_to do |format|
+      format.html do |variant|
+        variant.any   { render text: "any"   }
+        variant.phone { render text: "phone" }
+      end
+    end
+  end
+
+  def variant_inline_any
+    respond_to do |format|
+      format.html.any(:tablet, :phablet){ render text: "any" }
+      format.html.phone { render text: "phone" }
+    end
+  end
+
+  def variant_inline_any_any
+    respond_to do |format|
+      format.html.phone { render text: "phone" }
+      format.html.any   { render text: "any"   }
+    end
+  end
+
+  def variant_any_implicit_render
+    respond_to do |format|
+      format.html.phone
+      format.html.any(:tablet, :phablet)
+    end
+  end
+
+  def variant_any_with_none
+    respond_to do |format|
+      format.html.any(:none, :phone){ render text: "none or phone" }
+    end
+  end
+
+  def format_any_variant_any
+    respond_to do |format|
+      format.html { render text: "HTML" }
+      format.any(:js, :xml) do |variant|
+        variant.phone{ render text: "phone" }
+        variant.any(:tablet, :phablet){ render text: "tablet" }
+      end
+    end
+  end
+
+  protected
+    def set_layout
+      case action_name
+        when "all_types_with_layout", "iphone_with_html_response_type"
+          "respond_to/layouts/standard"
+        when "iphone_with_html_response_type_without_layout"
+          "respond_to/layouts/missing"
+      end
+    end
+end
+
+class RespondToControllerTest < ActionController::TestCase
+  tests RespondToController
+
+  def setup
+    super
+    @request.host = "www.example.com"
+    Mime::Type.register_alias("text/html", :iphone)
+    Mime::Type.register("text/x-mobile", :mobile)
+  end
+
+  def teardown
+    super
+    Mime::Type.unregister(:iphone)
+    Mime::Type.unregister(:mobile)
+  end
+
+  def test_html
+    @request.accept = "text/html"
+    get :js_or_html
+    assert_equal 'HTML', @response.body
+
+    get :html_or_xml
+    assert_equal 'HTML', @response.body
+
+    assert_raises(ActionController::UnknownFormat) do
+      get :just_xml
+    end
+  end
+
+  def test_all
+    @request.accept = "*/*"
+    get :js_or_html
+    assert_equal 'HTML', @response.body # js is not part of all
+
+    get :html_or_xml
+    assert_equal 'HTML', @response.body
+
+    get :just_xml
+    assert_equal 'XML', @response.body
+  end
+
+  def test_xml
+    @request.accept = "application/xml"
+    get :html_xml_or_rss
+    assert_equal 'XML', @response.body
+  end
+
+  def test_js_or_html
+    @request.accept = "text/javascript, text/html"
+    xhr :get, :js_or_html
+    assert_equal 'JS', @response.body
+
+    @request.accept = "text/javascript, text/html"
+    xhr :get, :html_or_xml
+    assert_equal 'HTML', @response.body
+
+    @request.accept = "text/javascript, text/html"
+
+    assert_raises(ActionController::UnknownFormat) do
+      xhr :get, :just_xml
+    end
+  end
+
+  def test_json_or_yaml_with_leading_star_star
+    @request.accept = "*/*, application/json"
+    get :json_xml_or_html
+    assert_equal 'HTML', @response.body
+
+    @request.accept = "*/* , application/json"
+    get :json_xml_or_html
+    assert_equal 'HTML', @response.body
+  end
+
+  def test_json_or_yaml
+    xhr :get, :json_or_yaml
+    assert_equal 'JSON', @response.body
+
+    get :json_or_yaml, :format => 'json'
+    assert_equal 'JSON', @response.body
+
+    get :json_or_yaml, :format => 'yaml'
+    assert_equal 'YAML', @response.body
+
+    { 'YAML' => %w(text/yaml),
+      'JSON' => %w(application/json text/x-json)
+    }.each do |body, content_types|
+      content_types.each do |content_type|
+        @request.accept = content_type
+        get :json_or_yaml
+        assert_equal body, @response.body
+      end
+    end
+  end
+
+  def test_js_or_anything
+    @request.accept = "text/javascript, */*"
+    xhr :get, :js_or_html
+    assert_equal 'JS', @response.body
+
+    xhr :get, :html_or_xml
+    assert_equal 'HTML', @response.body
+
+    xhr :get, :just_xml
+    assert_equal 'XML', @response.body
+  end
+
+  def test_using_defaults
+    @request.accept = "*/*"
+    get :using_defaults
+    assert_equal "text/html", @response.content_type
+    assert_equal 'Hello world!', @response.body
+
+    @request.accept = "application/xml"
+    get :using_defaults
+    assert_equal "application/xml", @response.content_type
+    assert_equal "<p>Hello world!</p>\n", @response.body
+  end
+
+  def test_using_defaults_with_all
+    @request.accept = "*/*"
+    get :using_defaults_with_all
+    assert_equal "HTML!", @response.body.strip
+
+    @request.accept = "text/html"
+    get :using_defaults_with_all
+    assert_equal "HTML!", @response.body.strip
+
+    @request.accept = "application/json"
+    get :using_defaults_with_all
+    assert_equal "ALL", @response.body
+  end
+
+  def test_using_defaults_with_type_list
+    @request.accept = "*/*"
+    get :using_defaults_with_type_list
+    assert_equal "text/html", @response.content_type
+    assert_equal 'Hello world!', @response.body
+
+    @request.accept = "application/xml"
+    get :using_defaults_with_type_list
+    assert_equal "application/xml", @response.content_type
+    assert_equal "<p>Hello world!</p>\n", @response.body
+  end
+
+  def test_with_atom_content_type
+    @request.accept = ""
+    @request.env["CONTENT_TYPE"] = "application/atom+xml"
+    xhr :get, :made_for_content_type
+    assert_equal "ATOM", @response.body
+  end
+
+  def test_with_rss_content_type
+    @request.accept = ""
+    @request.env["CONTENT_TYPE"] = "application/rss+xml"
+    xhr :get, :made_for_content_type
+    assert_equal "RSS", @response.body
+  end
+
+  def test_synonyms
+    @request.accept = "application/javascript"
+    get :js_or_html
+    assert_equal 'JS', @response.body
+
+    @request.accept = "application/x-xml"
+    get :html_xml_or_rss
+    assert_equal "XML", @response.body
+  end
+
+  def test_custom_types
+    @request.accept = "application/crazy-xml"
+    get :custom_type_handling
+    assert_equal "application/crazy-xml", @response.content_type
+    assert_equal 'Crazy XML', @response.body
+
+    @request.accept = "text/html"
+    get :custom_type_handling
+    assert_equal "text/html", @response.content_type
+    assert_equal 'HTML', @response.body
+  end
+
+  def test_xhtml_alias
+    @request.accept = "application/xhtml+xml,application/xml"
+    get :html_or_xml
+    assert_equal 'HTML', @response.body
+  end
+
+  def test_firefox_simulation
+    @request.accept = "text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5"
+    get :html_or_xml
+    assert_equal 'HTML', @response.body
+  end
+
+  def test_handle_any
+    @request.accept = "*/*"
+    get :handle_any
+    assert_equal 'HTML', @response.body
+
+    @request.accept = "text/javascript"
+    get :handle_any
+    assert_equal 'Either JS or XML', @response.body
+
+    @request.accept = "text/xml"
+    get :handle_any
+    assert_equal 'Either JS or XML', @response.body
+  end
+
+  def test_handle_any_any
+    @request.accept = "*/*"
+    get :handle_any_any
+    assert_equal 'HTML', @response.body
+  end
+
+  def test_handle_any_any_parameter_format
+    get :handle_any_any, {:format=>'html'}
+    assert_equal 'HTML', @response.body
+  end
+
+  def test_handle_any_any_explicit_html
+    @request.accept = "text/html"
+    get :handle_any_any
+    assert_equal 'HTML', @response.body
+  end
+
+  def test_handle_any_any_javascript
+    @request.accept = "text/javascript"
+    get :handle_any_any
+    assert_equal 'Whatever you ask for, I got it', @response.body
+  end
+
+  def test_handle_any_any_xml
+    @request.accept = "text/xml"
+    get :handle_any_any
+    assert_equal 'Whatever you ask for, I got it', @response.body
+  end
+
+  def test_browser_check_with_any_any
+    @request.accept = "application/json, application/xml"
+    get :json_xml_or_html
+    assert_equal 'JSON', @response.body
+
+    @request.accept = "application/json, application/xml, */*"
+    get :json_xml_or_html
+    assert_equal 'HTML', @response.body
+  end
+
+  def test_html_type_with_layout
+    @request.accept = "text/html"
+    get :all_types_with_layout
+    assert_equal '<html><div id="html">HTML for all_types_with_layout</div></html>', @response.body
+  end
+
+  def test_xhr
+    xhr :get, :js_or_html
+    assert_equal 'JS', @response.body
+  end
+
+  def test_custom_constant
+    get :custom_constant_handling, :format => "mobile"
+    assert_equal "text/x-mobile", @response.content_type
+    assert_equal "Mobile", @response.body
+  end
+
+  def test_custom_constant_handling_without_block
+    get :custom_constant_handling_without_block, :format => "mobile"
+    assert_equal "text/x-mobile", @response.content_type
+    assert_equal "Mobile", @response.body
+  end
+
+  def test_forced_format
+    get :html_xml_or_rss
+    assert_equal "HTML", @response.body
+
+    get :html_xml_or_rss, :format => "html"
+    assert_equal "HTML", @response.body
+
+    get :html_xml_or_rss, :format => "xml"
+    assert_equal "XML", @response.body
+
+    get :html_xml_or_rss, :format => "rss"
+    assert_equal "RSS", @response.body
+  end
+
+  def test_internally_forced_format
+    get :forced_xml
+    assert_equal "XML", @response.body
+
+    get :forced_xml, :format => "html"
+    assert_equal "XML", @response.body
+  end
+
+  def test_extension_synonyms
+    get :html_xml_or_rss, :format => "xhtml"
+    assert_equal "HTML", @response.body
+  end
+
+  def test_render_action_for_html
+    @controller.instance_eval do
+      def render(*args)
+        @action = args.first[:action] unless args.empty?
+        @action ||= action_name
+
+        response.body = "#{@action} - #{formats}"
+      end
+    end
+
+    get :using_defaults
+    assert_equal "using_defaults - #{[:html].to_s}", @response.body
+
+    get :using_defaults, :format => "xml"
+    assert_equal "using_defaults - #{[:xml].to_s}", @response.body
+  end
+
+  def test_format_with_custom_response_type
+    get :iphone_with_html_response_type
+    assert_equal '<html><div id="html">Hello future from Firefox!</div></html>', @response.body
+
+    get :iphone_with_html_response_type, :format => "iphone"
+    assert_equal "text/html", @response.content_type
+    assert_equal '<html><div id="iphone">Hello iPhone future from iPhone!</div></html>', @response.body
+  end
+
+  def test_format_with_custom_response_type_and_request_headers
+    @request.accept = "text/iphone"
+    get :iphone_with_html_response_type
+    assert_equal '<html><div id="iphone">Hello iPhone future from iPhone!</div></html>', @response.body
+    assert_equal "text/html", @response.content_type
+  end
+
+  def test_invalid_format
+    assert_raises(ActionController::UnknownFormat) do
+      get :using_defaults, :format => "invalidformat"
+    end
+  end
+
+  def test_invalid_variant
+    @request.variant = :invalid
+    assert_raises(ActionView::MissingTemplate) do
+      get :variant_with_implicit_rendering
+    end
+  end
+
+  def test_variant_not_set_regular_template_missing
+    assert_raises(ActionView::MissingTemplate) do
+      get :variant_with_implicit_rendering
+    end
+  end
+
+  def test_variant_with_implicit_rendering
+    @request.variant = :mobile
+    get :variant_with_implicit_rendering
+    assert_equal "text/html", @response.content_type
+    assert_equal "mobile", @response.body
+  end
+
+  def test_variant_with_format_and_custom_render
+    @request.variant = :phone
+    get :variant_with_format_and_custom_render
+    assert_equal "text/html", @response.content_type
+    assert_equal "mobile", @response.body
+  end
+
+  def test_multiple_variants_for_format
+    @request.variant = :tablet
+    get :multiple_variants_for_format
+    assert_equal "text/html", @response.content_type
+    assert_equal "tablet", @response.body
+  end
+
+  def test_no_variant_in_variant_setup
+    get :variant_plus_none_for_format
+    assert_equal "text/html", @response.content_type
+    assert_equal "none", @response.body
+  end
+
+  def test_variant_inline_syntax
+    get :variant_inline_syntax, format: :js
+    assert_equal "text/javascript", @response.content_type
+    assert_equal "js", @response.body
+
+    get :variant_inline_syntax
+    assert_equal "text/html", @response.content_type
+    assert_equal "none", @response.body
+
+    @request.variant = :phone
+    get :variant_inline_syntax
+    assert_equal "text/html", @response.content_type
+    assert_equal "phone", @response.body
+  end
+
+  def test_variant_inline_syntax_without_block
+    @request.variant = :phone
+    get :variant_inline_syntax_without_block
+    assert_equal "text/html", @response.content_type
+    assert_equal "phone", @response.body
+  end
+
+  def test_variant_any
+    @request.variant = :phone
+    get :variant_any
+    assert_equal "text/html", @response.content_type
+    assert_equal "phone", @response.body
+
+    @request.variant = :tablet
+    get :variant_any
+    assert_equal "text/html", @response.content_type
+    assert_equal "any", @response.body
+
+    @request.variant = :phablet
+    get :variant_any
+    assert_equal "text/html", @response.content_type
+    assert_equal "any", @response.body
+  end
+
+  def test_variant_any_any
+    @request.variant = :phone
+    get :variant_any_any
+    assert_equal "text/html", @response.content_type
+    assert_equal "phone", @response.body
+
+    @request.variant = :yolo
+    get :variant_any_any
+    assert_equal "text/html", @response.content_type
+    assert_equal "any", @response.body
+  end
+
+  def test_variant_inline_any
+    @request.variant = :phone
+    get :variant_any
+    assert_equal "text/html", @response.content_type
+    assert_equal "phone", @response.body
+
+    @request.variant = :tablet
+    get :variant_inline_any
+    assert_equal "text/html", @response.content_type
+    assert_equal "any", @response.body
+
+    @request.variant = :phablet
+    get :variant_inline_any
+    assert_equal "text/html", @response.content_type
+    assert_equal "any", @response.body
+  end
+
+  def test_variant_inline_any_any
+    @request.variant = :phone
+    get :variant_inline_any_any
+    assert_equal "text/html", @response.content_type
+    assert_equal "phone", @response.body
+
+    @request.variant = :yolo
+    get :variant_inline_any_any
+    assert_equal "text/html", @response.content_type
+    assert_equal "any", @response.body
+  end
+
+  def test_variant_any_implicit_render
+    @request.variant = :tablet
+    get :variant_any_implicit_render
+    assert_equal "text/html", @response.content_type
+    assert_equal "tablet", @response.body
+
+    @request.variant = :phablet
+    get :variant_any_implicit_render
+    assert_equal "text/html", @response.content_type
+    assert_equal "phablet", @response.body
+  end
+
+  def test_variant_any_with_none
+    get :variant_any_with_none
+    assert_equal "text/html", @response.content_type
+    assert_equal "none or phone", @response.body
+
+    @request.variant = :phone
+    get :variant_any_with_none
+    assert_equal "text/html", @response.content_type
+    assert_equal "none or phone", @response.body
+  end
+
+  def test_format_any_variant_any
+    @request.variant = :tablet
+    get :format_any_variant_any, format: :js
+    assert_equal "text/javascript", @response.content_type
+    assert_equal "tablet", @response.body
+  end
+end
diff --git a/actionpack/test/controller/mime_responds_test.rb b/actionpack/test/controller/mime/respond_with_test.rb
index a9c62899b5..a70592fa1b 100644
--- a/actionpack/test/controller/mime_responds_test.rb
+++ b/actionpack/test/controller/mime/respond_with_test.rb
@@ -1,529 +1,5 @@
 require 'abstract_unit'
 require 'controller/fake_models'
-require 'active_support/core_ext/hash/conversions'
-
-class StarStarMimeController < ActionController::Base
-  layout nil
-
-  def index
-    render
-  end
-end
-
-class RespondToController < ActionController::Base
-  layout :set_layout
-
-  def html_xml_or_rss
-    respond_to do |type|
-      type.html { render :text => "HTML"    }
-      type.xml  { render :text => "XML"     }
-      type.rss  { render :text => "RSS"     }
-      type.all  { render :text => "Nothing" }
-    end
-  end
-
-  def js_or_html
-    respond_to do |type|
-      type.html { render :text => "HTML"    }
-      type.js   { render :text => "JS"      }
-      type.all  { render :text => "Nothing" }
-    end
-  end
-
-  def json_or_yaml
-    respond_to do |type|
-      type.json { render :text => "JSON" }
-      type.yaml { render :text => "YAML" }
-    end
-  end
-
-  def html_or_xml
-    respond_to do |type|
-      type.html { render :text => "HTML"    }
-      type.xml  { render :text => "XML"     }
-      type.all  { render :text => "Nothing" }
-    end
-  end
-
-  def json_xml_or_html
-    respond_to do |type|
-      type.json { render :text => 'JSON' }
-      type.xml { render :xml => 'XML' }
-      type.html { render :text => 'HTML' }
-    end
-  end
-
-
-  def forced_xml
-    request.format = :xml
-
-    respond_to do |type|
-      type.html { render :text => "HTML"    }
-      type.xml  { render :text => "XML"     }
-    end
-  end
-
-  def just_xml
-    respond_to do |type|
-      type.xml  { render :text => "XML" }
-    end
-  end
-
-  def using_defaults
-    respond_to do |type|
-      type.html
-      type.xml
-    end
-  end
-
-  def using_defaults_with_type_list
-    respond_to(:html, :xml)
-  end
-
-  def using_defaults_with_all
-    respond_to do |type|
-      type.html
-      type.all{ render text: "ALL" }
-    end
-  end
-
-  def made_for_content_type
-    respond_to do |type|
-      type.rss  { render :text => "RSS"  }
-      type.atom { render :text => "ATOM" }
-      type.all  { render :text => "Nothing" }
-    end
-  end
-
-  def custom_type_handling
-    respond_to do |type|
-      type.html { render :text => "HTML"    }
-      type.custom("application/crazy-xml")  { render :text => "Crazy XML"  }
-      type.all  { render :text => "Nothing" }
-    end
-  end
-
-
-  def custom_constant_handling
-    respond_to do |type|
-      type.html   { render :text => "HTML"   }
-      type.mobile { render :text => "Mobile" }
-    end
-  end
-
-  def custom_constant_handling_without_block
-    respond_to do |type|
-      type.html   { render :text => "HTML"   }
-      type.mobile
-    end
-  end
-
-  def handle_any
-    respond_to do |type|
-      type.html { render :text => "HTML" }
-      type.any(:js, :xml) { render :text => "Either JS or XML" }
-    end
-  end
-
-  def handle_any_any
-    respond_to do |type|
-      type.html { render :text => 'HTML' }
-      type.any { render :text => 'Whatever you ask for, I got it' }
-    end
-  end
-
-  def all_types_with_layout
-    respond_to do |type|
-      type.html
-    end
-  end
-
-  def iphone_with_html_response_type
-    request.format = :iphone if request.env["HTTP_ACCEPT"] == "text/iphone"
-
-    respond_to do |type|
-      type.html   { @type = "Firefox" }
-      type.iphone { @type = "iPhone"  }
-    end
-  end
-
-  def iphone_with_html_response_type_without_layout
-    request.format = "iphone" if request.env["HTTP_ACCEPT"] == "text/iphone"
-
-    respond_to do |type|
-      type.html   { @type = "Firefox"; render :action => "iphone_with_html_response_type" }
-      type.iphone { @type = "iPhone" ; render :action => "iphone_with_html_response_type" }
-    end
-  end
-
-  protected
-    def set_layout
-      case action_name
-        when "all_types_with_layout", "iphone_with_html_response_type"
-          "respond_to/layouts/standard"
-        when "iphone_with_html_response_type_without_layout"
-          "respond_to/layouts/missing"
-      end
-    end
-end
-
-class StarStarMimeControllerTest < ActionController::TestCase
-  tests StarStarMimeController
-
-  def test_javascript_with_format
-    @request.accept = "text/javascript"
-    get :index, :format => 'js'
-    assert_match "function addition(a,b){ return a+b; }", @response.body
-  end
-
-  def test_javascript_with_no_format
-    @request.accept = "text/javascript"
-    get :index
-    assert_match "function addition(a,b){ return a+b; }", @response.body
-  end
-
-  def test_javascript_with_no_format_only_star_star
-    @request.accept = "*/*"
-    get :index
-    assert_match "function addition(a,b){ return a+b; }", @response.body
-  end
-
-end
-
-class RespondToControllerTest < ActionController::TestCase
-  tests RespondToController
-
-  def setup
-    super
-    @request.host = "www.example.com"
-    Mime::Type.register_alias("text/html", :iphone)
-    Mime::Type.register("text/x-mobile", :mobile)
-  end
-
-  def teardown
-    super
-    Mime::Type.unregister(:iphone)
-    Mime::Type.unregister(:mobile)
-  end
-
-  def test_html
-    @request.accept = "text/html"
-    get :js_or_html
-    assert_equal 'HTML', @response.body
-
-    get :html_or_xml
-    assert_equal 'HTML', @response.body
-
-    assert_raises(ActionController::UnknownFormat) do
-      get :just_xml
-    end
-  end
-
-  def test_all
-    @request.accept = "*/*"
-    get :js_or_html
-    assert_equal 'HTML', @response.body # js is not part of all
-
-    get :html_or_xml
-    assert_equal 'HTML', @response.body
-
-    get :just_xml
-    assert_equal 'XML', @response.body
-  end
-
-  def test_xml
-    @request.accept = "application/xml"
-    get :html_xml_or_rss
-    assert_equal 'XML', @response.body
-  end
-
-  def test_js_or_html
-    @request.accept = "text/javascript, text/html"
-    xhr :get, :js_or_html
-    assert_equal 'JS', @response.body
-
-    @request.accept = "text/javascript, text/html"
-    xhr :get, :html_or_xml
-    assert_equal 'HTML', @response.body
-
-    @request.accept = "text/javascript, text/html"
-
-    assert_raises(ActionController::UnknownFormat) do
-      xhr :get, :just_xml
-    end
-  end
-
-  def test_json_or_yaml_with_leading_star_star
-    @request.accept = "*/*, application/json"
-    get :json_xml_or_html
-    assert_equal 'HTML', @response.body
-
-    @request.accept = "*/* , application/json"
-    get :json_xml_or_html
-    assert_equal 'HTML', @response.body
-  end
-
-  def test_json_or_yaml
-    xhr :get, :json_or_yaml
-    assert_equal 'JSON', @response.body
-
-    get :json_or_yaml, :format => 'json'
-    assert_equal 'JSON', @response.body
-
-    get :json_or_yaml, :format => 'yaml'
-    assert_equal 'YAML', @response.body
-
-    { 'YAML' => %w(text/yaml),
-      'JSON' => %w(application/json text/x-json)
-    }.each do |body, content_types|
-      content_types.each do |content_type|
-        @request.accept = content_type
-        get :json_or_yaml
-        assert_equal body, @response.body
-      end
-    end
-  end
-
-  def test_js_or_anything
-    @request.accept = "text/javascript, */*"
-    xhr :get, :js_or_html
-    assert_equal 'JS', @response.body
-
-    xhr :get, :html_or_xml
-    assert_equal 'HTML', @response.body
-
-    xhr :get, :just_xml
-    assert_equal 'XML', @response.body
-  end
-
-  def test_using_defaults
-    @request.accept = "*/*"
-    get :using_defaults
-    assert_equal "text/html", @response.content_type
-    assert_equal 'Hello world!', @response.body
-
-    @request.accept = "application/xml"
-    get :using_defaults
-    assert_equal "application/xml", @response.content_type
-    assert_equal "<p>Hello world!</p>\n", @response.body
-  end
-
-  def test_using_defaults_with_all
-    @request.accept = "*/*"
-    get :using_defaults_with_all
-    assert_equal "HTML!", @response.body.strip
-
-    @request.accept = "text/html"
-    get :using_defaults_with_all
-    assert_equal "HTML!", @response.body.strip
-
-    @request.accept = "application/json"
-    get :using_defaults_with_all
-    assert_equal "ALL", @response.body
-  end
-
-  def test_using_defaults_with_type_list
-    @request.accept = "*/*"
-    get :using_defaults_with_type_list
-    assert_equal "text/html", @response.content_type
-    assert_equal 'Hello world!', @response.body
-
-    @request.accept = "application/xml"
-    get :using_defaults_with_type_list
-    assert_equal "application/xml", @response.content_type
-    assert_equal "<p>Hello world!</p>\n", @response.body
-  end
-
-  def test_with_atom_content_type
-    @request.accept = ""
-    @request.env["CONTENT_TYPE"] = "application/atom+xml"
-    xhr :get, :made_for_content_type
-    assert_equal "ATOM", @response.body
-  end
-
-  def test_with_rss_content_type
-    @request.accept = ""
-    @request.env["CONTENT_TYPE"] = "application/rss+xml"
-    xhr :get, :made_for_content_type
-    assert_equal "RSS", @response.body
-  end
-
-  def test_synonyms
-    @request.accept = "application/javascript"
-    get :js_or_html
-    assert_equal 'JS', @response.body
-
-    @request.accept = "application/x-xml"
-    get :html_xml_or_rss
-    assert_equal "XML", @response.body
-  end
-
-  def test_custom_types
-    @request.accept = "application/crazy-xml"
-    get :custom_type_handling
-    assert_equal "application/crazy-xml", @response.content_type
-    assert_equal 'Crazy XML', @response.body
-
-    @request.accept = "text/html"
-    get :custom_type_handling
-    assert_equal "text/html", @response.content_type
-    assert_equal 'HTML', @response.body
-  end
-
-  def test_xhtml_alias
-    @request.accept = "application/xhtml+xml,application/xml"
-    get :html_or_xml
-    assert_equal 'HTML', @response.body
-  end
-
-  def test_firefox_simulation
-    @request.accept = "text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5"
-    get :html_or_xml
-    assert_equal 'HTML', @response.body
-  end
-
-  def test_handle_any
-    @request.accept = "*/*"
-    get :handle_any
-    assert_equal 'HTML', @response.body
-
-    @request.accept = "text/javascript"
-    get :handle_any
-    assert_equal 'Either JS or XML', @response.body
-
-    @request.accept = "text/xml"
-    get :handle_any
-    assert_equal 'Either JS or XML', @response.body
-  end
-
-  def test_handle_any_any
-    @request.accept = "*/*"
-    get :handle_any_any
-    assert_equal 'HTML', @response.body
-  end
-
-  def test_handle_any_any_parameter_format
-    get :handle_any_any, {:format=>'html'}
-    assert_equal 'HTML', @response.body
-  end
-
-  def test_handle_any_any_explicit_html
-    @request.accept = "text/html"
-    get :handle_any_any
-    assert_equal 'HTML', @response.body
-  end
-
-  def test_handle_any_any_javascript
-    @request.accept = "text/javascript"
-    get :handle_any_any
-    assert_equal 'Whatever you ask for, I got it', @response.body
-  end
-
-  def test_handle_any_any_xml
-    @request.accept = "text/xml"
-    get :handle_any_any
-    assert_equal 'Whatever you ask for, I got it', @response.body
-  end
-
-  def test_browser_check_with_any_any
-    @request.accept = "application/json, application/xml"
-    get :json_xml_or_html
-    assert_equal 'JSON', @response.body
-
-    @request.accept = "application/json, application/xml, */*"
-    get :json_xml_or_html
-    assert_equal 'HTML', @response.body
-  end
-
-  def test_html_type_with_layout
-    @request.accept = "text/html"
-    get :all_types_with_layout
-    assert_equal '<html><div id="html">HTML for all_types_with_layout</div></html>', @response.body
-  end
-
-  def test_xhr
-    xhr :get, :js_or_html
-    assert_equal 'JS', @response.body
-  end
-
-  def test_custom_constant
-    get :custom_constant_handling, :format => "mobile"
-    assert_equal "text/x-mobile", @response.content_type
-    assert_equal "Mobile", @response.body
-  end
-
-  def test_custom_constant_handling_without_block
-    get :custom_constant_handling_without_block, :format => "mobile"
-    assert_equal "text/x-mobile", @response.content_type
-    assert_equal "Mobile", @response.body
-  end
-
-  def test_forced_format
-    get :html_xml_or_rss
-    assert_equal "HTML", @response.body
-
-    get :html_xml_or_rss, :format => "html"
-    assert_equal "HTML", @response.body
-
-    get :html_xml_or_rss, :format => "xml"
-    assert_equal "XML", @response.body
-
-    get :html_xml_or_rss, :format => "rss"
-    assert_equal "RSS", @response.body
-  end
-
-  def test_internally_forced_format
-    get :forced_xml
-    assert_equal "XML", @response.body
-
-    get :forced_xml, :format => "html"
-    assert_equal "XML", @response.body
-  end
-
-  def test_extension_synonyms
-    get :html_xml_or_rss, :format => "xhtml"
-    assert_equal "HTML", @response.body
-  end
-
-  def test_render_action_for_html
-    @controller.instance_eval do
-      def render(*args)
-        @action = args.first[:action] unless args.empty?
-        @action ||= action_name
-
-        response.body = "#{@action} - #{formats}"
-      end
-    end
-
-    get :using_defaults
-    assert_equal "using_defaults - #{[:html].to_s}", @response.body
-
-    get :using_defaults, :format => "xml"
-    assert_equal "using_defaults - #{[:xml].to_s}", @response.body
-  end
-
-  def test_format_with_custom_response_type
-    get :iphone_with_html_response_type
-    assert_equal '<html><div id="html">Hello future from Firefox!</div></html>', @response.body
-
-    get :iphone_with_html_response_type, :format => "iphone"
-    assert_equal "text/html", @response.content_type
-    assert_equal '<html><div id="iphone">Hello iPhone future from iPhone!</div></html>', @response.body
-  end
-
-  def test_format_with_custom_response_type_and_request_headers
-    @request.accept = "text/iphone"
-    get :iphone_with_html_response_type
-    assert_equal '<html><div id="iphone">Hello iPhone future from iPhone!</div></html>', @response.body
-    assert_equal "text/html", @response.content_type
-  end
-
-  def test_invalid_format
-    assert_raises(ActionController::UnknownFormat) do
-      get :using_defaults, :format => "invalidformat"
-    end
-  end
-end
 
 class RespondWithController < ActionController::Base
   respond_to :html, :json, :touch
@@ -589,7 +65,17 @@ class RespondWithController < ActionController::Base
     respond_with(resource, :responder => responder)
   end
 
+  def respond_with_additional_params
+    @params = RespondWithController.params
+    respond_with({:result => resource}, @params)
+  end
+
 protected
+  def self.params
+    {
+        :foo => 'bar'
+    }
+  end
 
   def resource
     Customer.new("david", request.delete? ? nil : 13)
@@ -631,6 +117,20 @@ class RenderJsonRespondWithController < RespondWithController
   end
 end
 
+class CsvRespondWithController < ActionController::Base
+  respond_to :csv
+
+  class RespondWithCsv
+    def to_csv
+      "c,s,v"
+    end
+  end
+
+  def index
+    respond_with(RespondWithCsv.new)
+  end
+end
+
 class EmptyRespondWithController < ActionController::Base
   def index
     respond_with(Customer.new("david", 13))
@@ -655,6 +155,11 @@ class RespondWithControllerTest < ActionController::TestCase
     Mime::Type.unregister(:mobile)
   end
 
+  def test_respond_with_shouldnt_modify_original_hash
+    get :respond_with_additional_params
+    assert_equal RespondWithController.params, assigns(:params)
+  end
+
   def test_using_resource
     @request.accept = "application/xml"
     get :using_resource
@@ -847,6 +352,7 @@ class RespondWithControllerTest < ActionController::TestCase
       errors = { :name => :invalid }
       Customer.any_instance.stubs(:errors).returns(errors)
       put :using_resource
+
       assert_equal "text/html", @response.content_type
       assert_equal 200, @response.status
       assert_equal "Edit world!\n", @response.body
@@ -1131,6 +637,23 @@ class RespondWithControllerTest < ActionController::TestCase
     RespondWithController.responder = ActionController::Responder
   end
 
+  def test_uses_renderer_if_an_api_behavior
+    ActionController::Renderers.add :csv do |obj, options|
+      send_data obj.to_csv, type: Mime::CSV
+    end
+    @controller = CsvRespondWithController.new
+    get :index, format: 'csv'
+    assert_equal Mime::CSV, @response.content_type
+    assert_equal "c,s,v", @response.body
+  end
+
+  def test_raises_missing_renderer_if_an_api_behavior_with_no_renderer
+    @controller = CsvRespondWithController.new
+    assert_raise ActionController::MissingRenderer do
+      get :index, format: 'csv'
+    end
+  end
+
   def test_error_is_raised_if_no_respond_to_is_declared_and_respond_with_is_called
     @controller = EmptyRespondWithController.new
     @request.accept = "*/*"
@@ -1154,69 +677,6 @@ class RespondWithControllerTest < ActionController::TestCase
     end
 end
 
-class AbstractPostController < ActionController::Base
-  self.view_paths = File.dirname(__FILE__) + "/../fixtures/post_test/"
-end
-
-# For testing layouts which are set automatically
-class PostController < AbstractPostController
-  around_action :with_iphone
-
-  def index
-    respond_to(:html, :iphone, :js)
-  end
-
-protected
-
-  def with_iphone
-    request.format = "iphone" if request.env["HTTP_ACCEPT"] == "text/iphone"
-    yield
-  end
-end
-
-class SuperPostController < PostController
-end
-
-class MimeControllerLayoutsTest < ActionController::TestCase
-  tests PostController
-
-  def setup
-    super
-    @request.host = "www.example.com"
-    Mime::Type.register_alias("text/html", :iphone)
-  end
-
-  def teardown
-    super
-    Mime::Type.unregister(:iphone)
-  end
-
-  def test_missing_layout_renders_properly
-    get :index
-    assert_equal '<html><div id="html">Hello Firefox</div></html>', @response.body
-
-    @request.accept = "text/iphone"
-    get :index
-    assert_equal 'Hello iPhone', @response.body
-  end
-
-  def test_format_with_inherited_layouts
-    @controller = SuperPostController.new
-
-    get :index
-    assert_equal '<html><div id="html">Super Firefox</div></html>', @response.body
-
-    @request.accept = "text/iphone"
-    get :index
-    assert_equal '<html><div id="super_iphone">Super iPhone</div></html>', @response.body
-  end
-
-  def test_non_navigational_format_with_no_template_fallbacks_to_html_template_with_no_layout
-    get :index, :format => :js
-    assert_equal "Hello Firefox", @response.body
-  end
-end
-
 class FlashResponder < ActionController::Responder
   def initialize(controller, resources, options={})
     super
diff --git a/actionpack/test/controller/new_base/render_streaming_test.rb b/actionpack/test/controller/new_base/render_streaming_test.rb
index f4bdd3e1d4..4c9126ca8c 100644
--- a/actionpack/test/controller/new_base/render_streaming_test.rb
+++ b/actionpack/test/controller/new_base/render_streaming_test.rb
@@ -4,7 +4,7 @@ module RenderStreaming
   class BasicController < ActionController::Base
     self.view_paths = [ActionView::FixtureResolver.new(
       "render_streaming/basic/hello_world.html.erb" => "Hello world",
-      "render_streaming/basic/boom.html.erb" => "<%= nil.invalid! %>",
+      "render_streaming/basic/boom.html.erb" => "<%= raise 'Ruby was here!' %>",
       "layouts/application.html.erb" => "<%= yield %>, I'm here!",
       "layouts/boom.html.erb" => "<body class=\"<%= nil.invalid! %>\"<%= yield %></body>"
     )]
@@ -90,9 +90,9 @@ module RenderStreaming
       begin
         get "/render_streaming/basic/template_exception"
         io.rewind
-        assert_match "(undefined method `invalid!' for nil:NilClass)", io.read
+        assert_match "Ruby was here!", io.read
       ensure
-        ActionController::Base.logger = _old
+        ActionView::Base.logger = _old
       end
     end
 
diff --git a/actionpack/test/controller/new_base/render_template_test.rb b/actionpack/test/controller/new_base/render_template_test.rb
index 6b2ae2b2a9..b7a9cf92f2 100644
--- a/actionpack/test/controller/new_base/render_template_test.rb
+++ b/actionpack/test/controller/new_base/render_template_test.rb
@@ -14,7 +14,7 @@ module RenderTemplate
       "test/with_json.html.erb"    => "<%= render :template => 'test/with_json', :formats => [:json] %>",
       "test/with_json.json.erb"    => "<%= render :template => 'test/final', :formats => [:json]  %>",
       "test/final.json.erb"        => "{ final: json }",
-      "test/with_error.html.erb"   => "<%= idontexist %>"
+      "test/with_error.html.erb"   => "<%= raise 'i do not exist' %>"
     )]
 
     def index
@@ -132,7 +132,7 @@ module RenderTemplate
     test "rendering a template with error properly excerts the code" do
       get :with_error
       assert_status 500
-      assert_match "undefined local variable or method `idontexist", response.body
+      assert_match "i do not exist", response.body
     end
   end
 
diff --git a/actionpack/test/controller/new_base/render_text_test.rb b/actionpack/test/controller/new_base/render_text_test.rb
index d6c3926a4d..2a253799f3 100644
--- a/actionpack/test/controller/new_base/render_text_test.rb
+++ b/actionpack/test/controller/new_base/render_text_test.rb
@@ -1,6 +1,15 @@
 require 'abstract_unit'
 
 module RenderText
+  class MinimalController < ActionController::Metal
+    include AbstractController::Rendering
+    include ActionController::Rendering
+
+    def index
+      render text: "Hello World!"
+    end
+  end
+
   class SimpleController < ActionController::Base
     self.view_paths = [ActionView::FixtureResolver.new]
 
@@ -63,6 +72,12 @@ module RenderText
   end
 
   class RenderTextTest < Rack::TestCase
+    test "rendering text from a minimal controller" do
+      get "/render_text/minimal/index"
+      assert_body "Hello World!"
+      assert_status 200
+    end
+
     test "rendering text from an action with default options renders the text with the layout" do
       with_routing do |set|
         set.draw { get ':controller', :action => 'index' }
diff --git a/actionpack/test/controller/parameters/nested_parameters_test.rb b/actionpack/test/controller/parameters/nested_parameters_test.rb
index 91df527dec..3b1257e8d5 100644
--- a/actionpack/test/controller/parameters/nested_parameters_test.rb
+++ b/actionpack/test/controller/parameters/nested_parameters_test.rb
@@ -169,4 +169,19 @@ class NestedParametersTest < ActiveSupport::TestCase
 
     assert_filtered_out permitted[:book][:authors_attributes]['-1'], :age_of_death
   end
+
+  test "nested number as key" do
+    params = ActionController::Parameters.new({
+      product: {
+        properties: {
+          '0' => "prop0",
+          '1' => "prop1"
+        }
+      }
+    })
+    params = params.require(:product).permit(:properties => ["0"])
+    assert_not_nil        params[:properties]["0"]
+    assert_nil            params[:properties]["1"]
+    assert_equal "prop0", params[:properties]["0"]
+  end
 end
diff --git a/actionpack/test/controller/parameters/parameters_permit_test.rb b/actionpack/test/controller/parameters/parameters_permit_test.rb
index 437da43d9b..33a91d72d9 100644
--- a/actionpack/test/controller/parameters/parameters_permit_test.rb
+++ b/actionpack/test/controller/parameters/parameters_permit_test.rb
@@ -8,9 +8,16 @@ class ParametersPermitTest < ActiveSupport::TestCase
   end
 
   setup do
-    @params = ActionController::Parameters.new({ person: {
-      age: "32", name: { first: "David", last: "Heinemeier Hansson" }
-    }})
+    @params = ActionController::Parameters.new(
+      person: {
+        age: '32',
+        name: {
+          first: 'David',
+          last: 'Heinemeier Hansson'
+        },
+        addresses: [{city: 'Chicago', state: 'Illinois'}]
+      }
+    )
 
     @struct_fields = []
     %w(0 1 12).each do |number|
@@ -107,6 +114,15 @@ class ParametersPermitTest < ActiveSupport::TestCase
     assert_equal [], permitted[:id]
   end
 
+  test 'do not break params filtering on nil values' do
+    params = ActionController::Parameters.new(a: 1, b: [1, 2, 3], c: nil)
+
+    permitted = params.permit(:a, c: [], b: [])
+    assert_equal 1, permitted[:a]
+    assert_equal [1, 2, 3], permitted[:b]
+    assert_equal nil, permitted[:c]
+  end
+
   test 'key to empty array: arrays of permitted scalars pass' do
     [['foo'], [1], ['foo', 'bar'], [1, 2, 3]].each do |array|
       params = ActionController::Parameters.new(id: array)
@@ -138,6 +154,24 @@ class ParametersPermitTest < ActiveSupport::TestCase
     assert_equal :foo, e.param
   end
 
+  test "fetch with a default value of a hash does not mutate the object" do
+    params = ActionController::Parameters.new({})
+    params.fetch :foo, {}
+    assert_equal nil, params[:foo]
+  end
+
+  test 'hashes in array values get wrapped' do
+    params = ActionController::Parameters.new(foo: [{}, {}])
+    params[:foo].each do |hash|
+      assert !hash.permitted?
+    end
+  end
+
+  test 'arrays are converted at most once' do
+    params = ActionController::Parameters.new(foo: [{}])
+    assert params[:foo].equal?(params[:foo])
+  end
+
   test "fetch doesnt raise ParameterMissing exception if there is a default" do
     assert_equal "monkey", @params.fetch(:foo, "monkey")
     assert_equal "monkey", @params.fetch(:foo) { "monkey" }
@@ -206,6 +240,7 @@ class ParametersPermitTest < ActiveSupport::TestCase
     assert @params.permitted?
     assert @params[:person].permitted?
     assert @params[:person][:name].permitted?
+    assert @params[:person][:addresses][0].permitted?
   end
 
   test "permitted takes a default value when Parameters.permit_all_parameters is set" do
diff --git a/actionpack/test/controller/record_identifier_test.rb b/actionpack/test/controller/record_identifier_test.rb
deleted file mode 100644
index ff5d7fd3bd..0000000000
--- a/actionpack/test/controller/record_identifier_test.rb
+++ /dev/null
@@ -1,34 +0,0 @@
-require 'abstract_unit'
-require 'controller/fake_models'
-
-class ControllerRecordIdentifierTest < ActiveSupport::TestCase
-  include ActionController::RecordIdentifier
-
-  def setup
-    @record = Comment.new
-  end
-
-  def test_dom_id_deprecation
-    assert_deprecated(/dom_id method will no longer be included by default in controllers/) do
-      dom_id(@record)
-    end
-  end
-
-  def test_dom_class_deprecation
-    assert_deprecated(/dom_class method will no longer be included by default in controllers/) do
-      dom_class(@record)
-    end
-  end
-
-  def test_dom_id_from_module_deprecation
-    assert_deprecated(/Calling ActionController::RecordIdentifier.dom_id is deprecated/) do
-      ActionController::RecordIdentifier.dom_id(@record)
-    end
-  end
-
-  def test_dom_class_from_module_deprecation
-    assert_deprecated(/Calling ActionController::RecordIdentifier.dom_class is deprecated/) do
-      ActionController::RecordIdentifier.dom_class(@record)
-    end
-  end
-end
diff --git a/actionpack/test/controller/render_js_test.rb b/actionpack/test/controller/render_js_test.rb
index f070109b27..d550422a2f 100644
--- a/actionpack/test/controller/render_js_test.rb
+++ b/actionpack/test/controller/render_js_test.rb
@@ -22,7 +22,7 @@ class RenderJSTest < ActionController::TestCase
   tests TestController
 
   def test_render_vanilla_js
-    get :render_vanilla_js_hello
+    xhr :get, :render_vanilla_js_hello
     assert_equal "alert('hello')", @response.body
     assert_equal "text/javascript", @response.content_type
   end
diff --git a/actionpack/test/controller/render_json_test.rb b/actionpack/test/controller/render_json_test.rb
index 7c0a6bd67e..de8d1cbd9b 100644
--- a/actionpack/test/controller/render_json_test.rb
+++ b/actionpack/test/controller/render_json_test.rb
@@ -100,13 +100,13 @@ class RenderJsonTest < ActionController::TestCase
   end
 
   def test_render_json_with_callback
-    get :render_json_hello_world_with_callback
+    xhr :get, :render_json_hello_world_with_callback
     assert_equal 'alert({"hello":"world"})', @response.body
     assert_equal 'text/javascript', @response.content_type
   end
 
   def test_render_json_with_custom_content_type
-    get :render_json_with_custom_content_type
+    xhr :get, :render_json_with_custom_content_type
     assert_equal '{"hello":"world"}', @response.body
     assert_equal 'text/javascript', @response.content_type
   end
diff --git a/actionpack/test/controller/render_test.rb b/actionpack/test/controller/render_test.rb
index 72411ec900..26806fb03f 100644
--- a/actionpack/test/controller/render_test.rb
+++ b/actionpack/test/controller/render_test.rb
@@ -2,26 +2,6 @@ require 'abstract_unit'
 require 'controller/fake_models'
 require 'pathname'
 
-module Fun
-  class GamesController < ActionController::Base
-    # :ported:
-    def hello_world
-    end
-
-    def nested_partial_with_form_builder
-      render :partial => ActionView::Helpers::FormBuilder.new(:post, nil, view_context, {})
-    end
-  end
-end
-
-module Quiz
-  class QuestionsController < ActionController::Base
-    def new
-      render :partial => Quiz::Question.new("Namespaced Partial")
-    end
-  end
-end
-
 class TestControllerWithExtraEtags < ActionController::Base
   etag { nil  }
   etag { 'ab' }
@@ -58,10 +38,6 @@ class TestController < ActionController::Base
   def hello_world
   end
 
-  def hello_world_file
-    render :file => File.expand_path("../../fixtures/hello", __FILE__), :formats => [:html]
-  end
-
   def conditional_hello
     if stale?(:last_modified => Time.now.utc.beginning_of_day, :etag => [:foo, 123])
       render :action => 'hello_world'
@@ -147,327 +123,10 @@ class TestController < ActionController::Base
     fresh_when(:last_modified => Time.now.utc.beginning_of_day, :etag => [ :foo, 123 ])
   end
 
-  # :ported:
-  def render_hello_world
-    render :template => "test/hello_world"
-  end
-
-  def render_hello_world_with_last_modified_set
-    response.last_modified = Date.new(2008, 10, 10).to_time
-    render :template => "test/hello_world"
-  end
-
-  # :ported: compatibility
-  def render_hello_world_with_forward_slash
-    render :template => "/test/hello_world"
-  end
-
-  # :ported:
-  def render_template_in_top_directory
-    render :template => 'shared'
-  end
-
-  # :deprecated:
-  def render_template_in_top_directory_with_slash
-    render :template => '/shared'
-  end
-
-  # :ported:
-  def render_hello_world_from_variable
-    @person = "david"
-    render :text => "hello #{@person}"
-  end
-
-  # :ported:
-  def render_action_hello_world
-    render :action => "hello_world"
-  end
-
-  def render_action_upcased_hello_world
-    render :action => "Hello_world"
-  end
-
-  def render_action_hello_world_as_string
-    render "hello_world"
-  end
-
-  def render_action_hello_world_with_symbol
-    render :action => :hello_world
-  end
-
-  # :ported:
-  def render_text_hello_world
-    render :text => "hello world"
-  end
-
-  # :ported:
-  def render_text_hello_world_with_layout
-    @variable_for_layout = ", I am here!"
-    render :text => "hello world", :layout => true
-  end
-
-  def hello_world_with_layout_false
-    render :layout => false
-  end
-
-  # :ported:
-  def render_file_with_instance_variables
-    @secret = 'in the sauce'
-    path = File.join(File.dirname(__FILE__), '../fixtures/test/render_file_with_ivar')
-    render :file => path
-  end
-
-  # :ported:
-  def render_file_as_string_with_instance_variables
-    @secret = 'in the sauce'
-    path = File.expand_path(File.join(File.dirname(__FILE__), '../fixtures/test/render_file_with_ivar'))
-    render path
-  end
-
-  # :ported:
-  def render_file_not_using_full_path
-    @secret = 'in the sauce'
-    render :file => 'test/render_file_with_ivar'
-  end
-
-  def render_file_not_using_full_path_with_dot_in_path
-    @secret = 'in the sauce'
-    render :file => 'test/dot.directory/render_file_with_ivar'
-  end
-
-  def render_file_using_pathname
-    @secret = 'in the sauce'
-    render :file => Pathname.new(File.dirname(__FILE__)).join('..', 'fixtures', 'test', 'dot.directory', 'render_file_with_ivar')
-  end
-
-  def render_file_from_template
-    @secret = 'in the sauce'
-    @path = File.expand_path(File.join(File.dirname(__FILE__), '../fixtures/test/render_file_with_ivar'))
-  end
-
-  def render_file_with_locals
-    path = File.join(File.dirname(__FILE__), '../fixtures/test/render_file_with_locals')
-    render :file => path, :locals => {:secret => 'in the sauce'}
-  end
-
-  def render_file_as_string_with_locals
-    path = File.expand_path(File.join(File.dirname(__FILE__), '../fixtures/test/render_file_with_locals'))
-    render path, :locals => {:secret => 'in the sauce'}
-  end
-
-  def accessing_request_in_template
-    render :inline =>  "Hello: <%= request.host %>"
-  end
-
-  def accessing_logger_in_template
-    render :inline =>  "<%= logger.class %>"
-  end
-
-  def accessing_action_name_in_template
-    render :inline =>  "<%= action_name %>"
-  end
-
-  def accessing_controller_name_in_template
-    render :inline =>  "<%= controller_name %>"
-  end
-
-  # :ported:
-  def render_custom_code
-    render :text => "hello world", :status => 404
-  end
-
-  # :ported:
-  def render_text_with_nil
-    render :text => nil
-  end
-
-  # :ported:
-  def render_text_with_false
-    render :text => false
-  end
-
-  def render_text_with_resource
-    render :text => Customer.new("David")
-  end
-
-  # :ported:
-  def render_nothing_with_appendix
-    render :text => "appended"
-  end
-
-  # This test is testing 3 things:
-  #   render :file in AV      :ported:
-  #   render :template in AC  :ported:
-  #   setting content type
-  def render_xml_hello
-    @name = "David"
-    render :template => "test/hello"
-  end
-
-  def render_xml_hello_as_string_template
-    @name = "David"
-    render "test/hello"
-  end
-
-  def render_line_offset
-    render :inline => '<% raise %>', :locals => {:foo => 'bar'}
-  end
-
   def heading
     head :ok
   end
 
-  def greeting
-    # let's just rely on the template
-  end
-
-  # :ported:
-  def blank_response
-    render :text => ' '
-  end
-
-  # :ported:
-  def layout_test
-    render :action => "hello_world"
-  end
-
-  # :ported:
-  def builder_layout_test
-    @name = nil
-    render :action => "hello", :layout => "layouts/builder"
-  end
-
-  # :move: test this in Action View
-  def builder_partial_test
-    render :action => "hello_world_container"
-  end
-
-  # :ported:
-  def partials_list
-    @test_unchanged = 'hello'
-    @customers = [ Customer.new("david"), Customer.new("mary") ]
-    render :action => "list"
-  end
-
-  def partial_only
-    render :partial => true
-  end
-
-  def hello_in_a_string
-    @customers = [ Customer.new("david"), Customer.new("mary") ]
-    render :text => "How's there? " + render_to_string(:template => "test/list")
-  end
-
-  def accessing_params_in_template
-    render :inline => "Hello: <%= params[:name] %>"
-  end
-
-  def accessing_local_assigns_in_inline_template
-    name = params[:local_name]
-    render :inline => "<%= 'Goodbye, ' + local_name %>",
-           :locals => { :local_name => name }
-  end
-
-  def render_implicit_html_template_from_xhr_request
-  end
-
-  def render_implicit_js_template_without_layout
-  end
-
-  def formatted_html_erb
-  end
-
-  def formatted_xml_erb
-  end
-
-  def render_to_string_test
-    @foo = render_to_string :inline => "this is a test"
-  end
-
-  def default_render
-    @alternate_default_render ||= nil
-    if @alternate_default_render
-      @alternate_default_render.call
-    else
-      super
-    end
-  end
-
-  def render_action_hello_world_as_symbol
-    render :action => :hello_world
-  end
-
-  def layout_test_with_different_layout
-    render :action => "hello_world", :layout => "standard"
-  end
-
-  def layout_test_with_different_layout_and_string_action
-    render "hello_world", :layout => "standard"
-  end
-
-  def layout_test_with_different_layout_and_symbol_action
-    render :hello_world, :layout => "standard"
-  end
-
-  def rendering_without_layout
-    render :action => "hello_world", :layout => false
-  end
-
-  def layout_overriding_layout
-    render :action => "hello_world", :layout => "standard"
-  end
-
-  def rendering_nothing_on_layout
-    render :nothing => true
-  end
-
-  def render_to_string_with_assigns
-    @before = "i'm before the render"
-    render_to_string :text => "foo"
-    @after = "i'm after the render"
-    render :template => "test/hello_world"
-  end
-
-  def render_to_string_with_exception
-    render_to_string :file => "exception that will not be caught - this will certainly not work"
-  end
-
-  def render_to_string_with_caught_exception
-    @before = "i'm before the render"
-    begin
-      render_to_string :file => "exception that will be caught- hope my future instance vars still work!"
-    rescue
-    end
-    @after = "i'm after the render"
-    render :template => "test/hello_world"
-  end
-
-  def accessing_params_in_template_with_layout
-    render :layout => true, :inline =>  "Hello: <%= params[:name] %>"
-  end
-
-  # :ported:
-  def render_with_explicit_template
-    render :template => "test/hello_world"
-  end
-
-  def render_with_explicit_unescaped_template
-    render :template => "test/h*llo_world"
-  end
-
-  def render_with_explicit_escaped_template
-    render :template => "test/hello,world"
-  end
-
-  def render_with_explicit_string_template
-    render "test/hello_world"
-  end
-
-  # :ported:
-  def render_with_explicit_template_with_locals
-    render :template => "test/render_file_with_locals", :locals => { :secret => 'area51' }
-  end
-
   # :ported:
   def double_render
     render :text => "hello"
@@ -508,25 +167,6 @@ class TestController < ActionController::Base
     render :template => "test/hello_world_from_rxml", :handlers => [:builder]
   end
 
-  def action_talk_to_layout
-    # Action template sets variable that's picked up by layout
-  end
-
-  # :addressed:
-  def render_text_with_assigns
-    @hello = "world"
-    render :text => "foo"
-  end
-
-  def yield_content_for
-    render :action => "content_for", :layout => "yield"
-  end
-
-  def render_content_type_from_body
-    response.content_type = Mime::RSS
-    render :text => "hello world!"
-  end
-
   def head_created
     head :created
   end
@@ -571,162 +211,6 @@ class TestController < ActionController::Base
     head :forbidden, :x_custom_header => "something"
   end
 
-  def render_using_layout_around_block
-    render :action => "using_layout_around_block"
-  end
-
-  def render_using_layout_around_block_in_main_layout_and_within_content_for_layout
-    render :action => "using_layout_around_block", :layout => "layouts/block_with_layout"
-  end
-
-  def partial_formats_html
-    render :partial => 'partial', :formats => [:html]
-  end
-
-  def partial
-    render :partial => 'partial'
-  end
-
-  def partial_html_erb
-    render :partial => 'partial_html_erb'
-  end
-
-  def render_to_string_with_partial
-    @partial_only = render_to_string :partial => "partial_only"
-    @partial_with_locals = render_to_string :partial => "customer", :locals => { :customer => Customer.new("david") }
-    render :template => "test/hello_world"
-  end
-
-  def render_to_string_with_template_and_html_partial
-    @text = render_to_string :template => "test/with_partial", :formats => [:text]
-    @html = render_to_string :template => "test/with_partial", :formats => [:html]
-    render :template => "test/with_html_partial"
-  end
-
-  def render_to_string_and_render_with_different_formats
-    @html = render_to_string :template => "test/with_partial", :formats => [:html]
-    render :template => "test/with_partial", :formats => [:text]
-  end
-
-  def render_template_within_a_template_with_other_format
-    render  :template => "test/with_xml_template",
-            :formats  => [:html],
-            :layout   => "with_html_partial"
-  end
-
-  def partial_with_counter
-    render :partial => "counter", :locals => { :counter_counter => 5 }
-  end
-
-  def partial_with_locals
-    render :partial => "customer", :locals => { :customer => Customer.new("david") }
-  end
-
-  def partial_with_form_builder
-    render :partial => ActionView::Helpers::FormBuilder.new(:post, nil, view_context, {})
-  end
-
-  def partial_with_form_builder_subclass
-    render :partial => LabellingFormBuilder.new(:post, nil, view_context, {})
-  end
-
-  def partial_collection
-    render :partial => "customer", :collection => [ Customer.new("david"), Customer.new("mary") ]
-  end
-
-  def partial_collection_with_as
-    render :partial => "customer_with_var", :collection => [ Customer.new("david"), Customer.new("mary") ], :as => :customer
-  end
-
-  def partial_collection_with_counter
-    render :partial => "customer_counter", :collection => [ Customer.new("david"), Customer.new("mary") ]
-  end
-
-  def partial_collection_with_as_and_counter
-    render :partial => "customer_counter_with_as", :collection => [ Customer.new("david"), Customer.new("mary") ], :as => :client
-  end
-
-  def partial_collection_with_locals
-    render :partial => "customer_greeting", :collection => [ Customer.new("david"), Customer.new("mary") ], :locals => { :greeting => "Bonjour" }
-  end
-
-  def partial_collection_with_spacer
-    render :partial => "customer", :spacer_template => "partial_only", :collection => [ Customer.new("david"), Customer.new("mary") ]
-  end
-
-  def partial_collection_with_spacer_which_uses_render
-    render :partial => "customer", :spacer_template => "partial_with_partial", :collection => [ Customer.new("david"), Customer.new("mary") ]
-  end
-
-  def partial_collection_shorthand_with_locals
-    render :partial => [ Customer.new("david"), Customer.new("mary") ], :locals => { :greeting => "Bonjour" }
-  end
-
-  def partial_collection_shorthand_with_different_types_of_records
-    render :partial => [
-        BadCustomer.new("mark"),
-        GoodCustomer.new("craig"),
-        BadCustomer.new("john"),
-        GoodCustomer.new("zach"),
-        GoodCustomer.new("brandon"),
-        BadCustomer.new("dan") ],
-      :locals => { :greeting => "Bonjour" }
-  end
-
-  def empty_partial_collection
-    render :partial => "customer", :collection => []
-  end
-
-  def partial_collection_shorthand_with_different_types_of_records_with_counter
-    partial_collection_shorthand_with_different_types_of_records
-  end
-
-  def missing_partial
-    render :partial => 'thisFileIsntHere'
-  end
-
-  def partial_with_hash_object
-    render :partial => "hash_object", :object => {:first_name => "Sam"}
-  end
-
-  def partial_with_nested_object
-    render :partial => "quiz/questions/question", :object => Quiz::Question.new("first")
-  end
-
-  def partial_with_nested_object_shorthand
-    render Quiz::Question.new("first")
-  end
-
-  def partial_hash_collection
-    render :partial => "hash_object", :collection => [ {:first_name => "Pratik"}, {:first_name => "Amy"} ]
-  end
-
-  def partial_hash_collection_with_locals
-    render :partial => "hash_greeting", :collection => [ {:first_name => "Pratik"}, {:first_name => "Amy"} ], :locals => { :greeting => "Hola" }
-  end
-
-  def partial_with_implicit_local_assignment
-    @customer = Customer.new("Marcel")
-    render :partial => "customer"
-  end
-
-  def render_call_to_partial_with_layout
-    render :action => "calling_partial_with_layout"
-  end
-
-  def render_call_to_partial_with_layout_in_main_layout_and_within_content_for_layout
-    render :action => "calling_partial_with_layout", :layout => "layouts/partial_with_layout"
-  end
-
-  before_action only: :render_with_filters do
-    request.format = :xml
-  end
-
-  # Ensure that the before filter is executed *before* self.formats is set.
-  def render_with_filters
-    render :action => :formatted_xml_erb
-  end
-
   private
 
     def set_variable_for_layout
@@ -755,6 +239,8 @@ class TestController < ActionController::Base
 end
 
 class MetalTestController < ActionController::Metal
+  include AbstractController::Rendering
+  include ActionView::Rendering
   include ActionController::Rendering
 
   def accessing_logger_in_template
@@ -762,782 +248,9 @@ class MetalTestController < ActionController::Metal
   end
 end
 
-class RenderTest < ActionController::TestCase
-  tests TestController
-
-  def setup
-    # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get
-    # a more accurate simulation of what happens in "real life".
-    super
-    @controller.logger      = ActiveSupport::Logger.new(nil)
-    ActionView::Base.logger = ActiveSupport::Logger.new(nil)
-
-    @request.host = "www.nextangle.com"
-  end
-
-  # :ported:
-  def test_simple_show
-    get :hello_world
-    assert_response 200
-    assert_response :success
-    assert_template "test/hello_world"
-    assert_equal "<html>Hello world!</html>", @response.body
-  end
-
-  # :ported:
-  def test_renders_default_template_for_missing_action
-    get :'hyphen-ated'
-    assert_template 'test/hyphen-ated'
-  end
-
-  # :ported:
-  def test_render
-    get :render_hello_world
-    assert_template "test/hello_world"
-  end
-
-  def test_line_offset
-    get :render_line_offset
-    flunk "the action should have raised an exception"
-  rescue StandardError => exc
-    line = exc.backtrace.first
-    assert(line =~ %r{:(\d+):})
-    assert_equal "1", $1,
-      "The line offset is wrong, perhaps the wrong exception has been raised, exception was: #{exc.inspect}"
-  end
-
-  # :ported: compatibility
-  def test_render_with_forward_slash
-    get :render_hello_world_with_forward_slash
-    assert_template "test/hello_world"
-  end
-
-  # :ported:
-  def test_render_in_top_directory
-    get :render_template_in_top_directory
-    assert_template "shared"
-    assert_equal "Elastica", @response.body
-  end
-
-  # :ported:
-  def test_render_in_top_directory_with_slash
-    get :render_template_in_top_directory_with_slash
-    assert_template "shared"
-    assert_equal "Elastica", @response.body
-  end
-
-  # :ported:
-  def test_render_from_variable
-    get :render_hello_world_from_variable
-    assert_equal "hello david", @response.body
-  end
-
-  # :ported:
-  def test_render_action
-    get :render_action_hello_world
-    assert_template "test/hello_world"
-  end
-
-  def test_render_action_upcased
-    assert_raise ActionView::MissingTemplate do
-      get :render_action_upcased_hello_world
-    end
-  end
-
-  # :ported:
-  def test_render_action_hello_world_as_string
-    get :render_action_hello_world_as_string
-    assert_equal "Hello world!", @response.body
-    assert_template "test/hello_world"
-  end
-
-  # :ported:
-  def test_render_action_with_symbol
-    get :render_action_hello_world_with_symbol
-    assert_template "test/hello_world"
-  end
-
-  # :ported:
-  def test_render_text
-    get :render_text_hello_world
-    assert_equal "hello world", @response.body
-  end
-
-  # :ported:
-  def test_do_with_render_text_and_layout
-    get :render_text_hello_world_with_layout
-    assert_equal "<html>hello world, I am here!</html>", @response.body
-  end
-
-  # :ported:
-  def test_do_with_render_action_and_layout_false
-    get :hello_world_with_layout_false
-    assert_equal 'Hello world!', @response.body
-  end
-
-  # :ported:
-  def test_render_file_with_instance_variables
-    get :render_file_with_instance_variables
-    assert_equal "The secret is in the sauce\n", @response.body
-  end
-
-  def test_render_file
-    get :hello_world_file
-    assert_equal "Hello world!", @response.body
-  end
-
-  # :ported:
-  def test_render_file_as_string_with_instance_variables
-    get :render_file_as_string_with_instance_variables
-    assert_equal "The secret is in the sauce\n", @response.body
-  end
-
-  # :ported:
-  def test_render_file_not_using_full_path
-    get :render_file_not_using_full_path
-    assert_equal "The secret is in the sauce\n", @response.body
-  end
-
-  # :ported:
-  def test_render_file_not_using_full_path_with_dot_in_path
-    get :render_file_not_using_full_path_with_dot_in_path
-    assert_equal "The secret is in the sauce\n", @response.body
-  end
-
-  # :ported:
-  def test_render_file_using_pathname
-    get :render_file_using_pathname
-    assert_equal "The secret is in the sauce\n", @response.body
-  end
-
-  # :ported:
-  def test_render_file_with_locals
-    get :render_file_with_locals
-    assert_equal "The secret is in the sauce\n", @response.body
-  end
-
-  # :ported:
-  def test_render_file_as_string_with_locals
-    get :render_file_as_string_with_locals
-    assert_equal "The secret is in the sauce\n", @response.body
-  end
-
-  # :assessed:
-  def test_render_file_from_template
-    get :render_file_from_template
-    assert_equal "The secret is in the sauce\n", @response.body
-  end
-
-  # :ported:
-  def test_render_custom_code
-    get :render_custom_code
-    assert_response 404
-    assert_response :missing
-    assert_equal 'hello world', @response.body
-  end
-
-  # :ported:
-  def test_render_text_with_nil
-    get :render_text_with_nil
-    assert_response 200
-    assert_equal ' ', @response.body
-  end
-
-  # :ported:
-  def test_render_text_with_false
-    get :render_text_with_false
-    assert_equal 'false', @response.body
-  end
-
-  # :ported:
-  def test_render_nothing_with_appendix
-    get :render_nothing_with_appendix
-    assert_response 200
-    assert_equal 'appended', @response.body
-  end
-
-  def test_render_text_with_resource
-    get :render_text_with_resource
-    assert_equal 'name: "David"', @response.body
-  end
-
-  # :ported:
-  def test_attempt_to_access_object_method
-    assert_raise(AbstractController::ActionNotFound, "No action responded to [clone]") { get :clone }
-  end
-
-  # :ported:
-  def test_private_methods
-    assert_raise(AbstractController::ActionNotFound, "No action responded to [determine_layout]") { get :determine_layout }
-  end
-
-  # :ported:
-  def test_access_to_request_in_view
-    get :accessing_request_in_template
-    assert_equal "Hello: www.nextangle.com", @response.body
-  end
-
-  def test_access_to_logger_in_view
-    get :accessing_logger_in_template
-    assert_equal "ActiveSupport::Logger", @response.body
-  end
-
-  # :ported:
-  def test_access_to_action_name_in_view
-    get :accessing_action_name_in_template
-    assert_equal "accessing_action_name_in_template", @response.body
-  end
-
-  # :ported:
-  def test_access_to_controller_name_in_view
-    get :accessing_controller_name_in_template
-    assert_equal "test", @response.body # name is explicitly set in the controller.
-  end
-
-  # :ported:
-  def test_render_xml
-    get :render_xml_hello
-    assert_equal "<html>\n  <p>Hello David</p>\n<p>This is grand!</p>\n</html>\n", @response.body
-    assert_equal "application/xml", @response.content_type
-  end
-
-  # :ported:
-  def test_render_xml_as_string_template
-    get :render_xml_hello_as_string_template
-    assert_equal "<html>\n  <p>Hello David</p>\n<p>This is grand!</p>\n</html>\n", @response.body
-    assert_equal "application/xml", @response.content_type
-  end
-
-  # :ported:
-  def test_render_xml_with_default
-    get :greeting
-    assert_equal "<p>This is grand!</p>\n", @response.body
-  end
-
-  # :move: test in AV
-  def test_render_xml_with_partial
-    get :builder_partial_test
-    assert_equal "<test>\n  <hello/>\n</test>\n", @response.body
-  end
-
-  # :ported:
-  def test_layout_rendering
-    get :layout_test
-    assert_equal "<html>Hello world!</html>", @response.body
-  end
-
-  def test_render_xml_with_layouts
-    get :builder_layout_test
-    assert_equal "<wrapper>\n<html>\n  <p>Hello </p>\n<p>This is grand!</p>\n</html>\n</wrapper>\n", @response.body
-  end
-
-  def test_partials_list
-    get :partials_list
-    assert_equal "goodbyeHello: davidHello: marygoodbye\n", @response.body
-  end
-
-  def test_render_to_string
-    get :hello_in_a_string
-    assert_equal "How's there? goodbyeHello: davidHello: marygoodbye\n", @response.body
-  end
-
-  def test_render_to_string_resets_assigns
-    get :render_to_string_test
-    assert_equal "The value of foo is: ::this is a test::\n", @response.body
-  end
-
-  def test_render_to_string_inline
-    get :render_to_string_with_inline_and_render
-    assert_template "test/hello_world"
-  end
-
-  # :ported:
-  def test_nested_rendering
-    @controller = Fun::GamesController.new
-    get :hello_world
-    assert_equal "Living in a nested world", @response.body
-  end
-
-  def test_accessing_params_in_template
-    get :accessing_params_in_template, :name => "David"
-    assert_equal "Hello: David", @response.body
-  end
-
-  def test_accessing_local_assigns_in_inline_template
-    get :accessing_local_assigns_in_inline_template, :local_name => "Local David"
-    assert_equal "Goodbye, Local David", @response.body
-    assert_equal "text/html", @response.content_type
-  end
-
-  def test_should_implicitly_render_html_template_from_xhr_request
-    xhr :get, :render_implicit_html_template_from_xhr_request
-    assert_equal "XHR!\nHello HTML!", @response.body
-  end
-
-  def test_should_implicitly_render_js_template_without_layout
-    get :render_implicit_js_template_without_layout, :format => :js
-    assert_no_match %r{<html>}, @response.body
-  end
-
-  def test_should_render_formatted_template
-    get :formatted_html_erb
-    assert_equal 'formatted html erb', @response.body
-  end
-
-  def test_should_render_formatted_html_erb_template
-    get :formatted_xml_erb
-    assert_equal '<test>passed formatted html erb</test>', @response.body
-  end
-
-  def test_should_render_formatted_html_erb_template_with_faulty_accepts_header
-    @request.accept = "image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, appliction/x-shockwave-flash, */*"
-    get :formatted_xml_erb
-    assert_equal '<test>passed formatted html erb</test>', @response.body
-  end
-
-  def test_layout_test_with_different_layout
-    get :layout_test_with_different_layout
-    assert_equal "<html>Hello world!</html>", @response.body
-  end
-
-  def test_layout_test_with_different_layout_and_string_action
-    get :layout_test_with_different_layout_and_string_action
-    assert_equal "<html>Hello world!</html>", @response.body
-  end
-
-  def test_layout_test_with_different_layout_and_symbol_action
-    get :layout_test_with_different_layout_and_symbol_action
-    assert_equal "<html>Hello world!</html>", @response.body
-  end
-
-  def test_rendering_without_layout
-    get :rendering_without_layout
-    assert_equal "Hello world!", @response.body
-  end
-
-  def test_layout_overriding_layout
-    get :layout_overriding_layout
-    assert_no_match %r{<title>}, @response.body
-  end
-
-  def test_rendering_nothing_on_layout
-    get :rendering_nothing_on_layout
-    assert_equal " ", @response.body
-  end
-
-  def test_render_to_string_doesnt_break_assigns
-    get :render_to_string_with_assigns
-    assert_equal "i'm before the render", assigns(:before)
-    assert_equal "i'm after the render", assigns(:after)
-  end
-
-  def test_bad_render_to_string_still_throws_exception
-    assert_raise(ActionView::MissingTemplate) { get :render_to_string_with_exception }
-  end
-
-  def test_render_to_string_that_throws_caught_exception_doesnt_break_assigns
-    assert_nothing_raised { get :render_to_string_with_caught_exception }
-    assert_equal "i'm before the render", assigns(:before)
-    assert_equal "i'm after the render", assigns(:after)
-  end
-
-  def test_accessing_params_in_template_with_layout
-    get :accessing_params_in_template_with_layout, :name => "David"
-    assert_equal "<html>Hello: David</html>", @response.body
-  end
-
-  def test_render_with_explicit_template
-    get :render_with_explicit_template
-    assert_response :success
-  end
-
-  def test_render_with_explicit_unescaped_template
-    assert_raise(ActionView::MissingTemplate) { get :render_with_explicit_unescaped_template }
-    get :render_with_explicit_escaped_template
-    assert_equal "Hello w*rld!", @response.body
-  end
-
-  def test_render_with_explicit_string_template
-    get :render_with_explicit_string_template
-    assert_equal "<html>Hello world!</html>", @response.body
-  end
-
-  def test_render_with_filters
-    get :render_with_filters
-    assert_equal "<test>passed formatted xml erb</test>", @response.body
-  end
-
-  # :ported:
-  def test_double_render
-    assert_raise(AbstractController::DoubleRenderError) { get :double_render }
-  end
-
-  def test_double_redirect
-    assert_raise(AbstractController::DoubleRenderError) { get :double_redirect }
-  end
-
-  def test_render_and_redirect
-    assert_raise(AbstractController::DoubleRenderError) { get :render_and_redirect }
-  end
-
-  # specify the one exception to double render rule - render_to_string followed by render
-  def test_render_to_string_and_render
-    get :render_to_string_and_render
-    assert_equal("Hi web users! here is some cached stuff", @response.body)
-  end
-
-  def test_rendering_with_conflicting_local_vars
-    get :rendering_with_conflicting_local_vars
-    assert_equal("First: David\nSecond: Stephan\nThird: David\nFourth: David\nFifth: ", @response.body)
-  end
-
-  def test_action_talk_to_layout
-    get :action_talk_to_layout
-    assert_equal "<title>Talking to the layout</title>\nAction was here!", @response.body
-  end
-
-  # :addressed:
-  def test_render_text_with_assigns
-    get :render_text_with_assigns
-    assert_equal "world", assigns["hello"]
-  end
-
-  # :ported:
-  def test_template_with_locals
-    get :render_with_explicit_template_with_locals
-    assert_equal "The secret is area51\n", @response.body
-  end
-
-  def test_yield_content_for
-    get :yield_content_for
-    assert_equal "<title>Putting stuff in the title!</title>\nGreat stuff!\n", @response.body
-  end
-
-  def test_overwritting_rendering_relative_file_with_extension
-    get :hello_world_from_rxml_using_template
-    assert_equal "<html>\n  <p>Hello</p>\n</html>\n", @response.body
-
-    get :hello_world_from_rxml_using_action
-    assert_equal "<html>\n  <p>Hello</p>\n</html>\n", @response.body
-  end
-
-  def test_head_created
-    post :head_created
-    assert @response.body.blank?
-    assert_response :created
-  end
-
-  def test_head_created_with_application_json_content_type
-    post :head_created_with_application_json_content_type
-    assert @response.body.blank?
-    assert_equal "application/json", @response.header["Content-Type"]
-    assert_response :created
-  end
-
-  def test_head_ok_with_image_png_content_type
-    post :head_ok_with_image_png_content_type
-    assert @response.body.blank?
-    assert_equal "image/png", @response.header["Content-Type"]
-    assert_response :ok
-  end
-
-  def test_head_with_location_header
-    get :head_with_location_header
-    assert @response.body.blank?
-    assert_equal "/foo", @response.headers["Location"]
-    assert_response :ok
-  end
-
-  def test_head_with_location_object
-    with_routing do |set|
-      set.draw do
-        resources :customers
-        get ':controller/:action'
-      end
-
-      get :head_with_location_object
-      assert @response.body.blank?
-      assert_equal "http://www.nextangle.com/customers/1", @response.headers["Location"]
-      assert_response :ok
-    end
-  end
-
-  def test_head_with_custom_header
-    get :head_with_custom_header
-    assert @response.body.blank?
-    assert_equal "something", @response.headers["X-Custom-Header"]
-    assert_response :ok
-  end
-
-  def test_head_with_www_authenticate_header
-    get :head_with_www_authenticate_header
-    assert @response.body.blank?
-    assert_equal "something", @response.headers["WWW-Authenticate"]
-    assert_response :ok
-  end
-
-  def test_head_with_symbolic_status
-    get :head_with_symbolic_status, :status => "ok"
-    assert_equal 200, @response.status
-    assert_response :ok
-
-    get :head_with_symbolic_status, :status => "not_found"
-    assert_equal 404, @response.status
-    assert_response :not_found
-
-    get :head_with_symbolic_status, :status => "no_content"
-    assert_equal 204, @response.status
-    assert !@response.headers.include?('Content-Length')
-    assert_response :no_content
-
-    Rack::Utils::SYMBOL_TO_STATUS_CODE.each do |status, code|
-      get :head_with_symbolic_status, :status => status.to_s
-      assert_equal code, @response.response_code
-      assert_response status
-    end
-  end
-
-  def test_head_with_integer_status
-    Rack::Utils::HTTP_STATUS_CODES.each do |code, message|
-      get :head_with_integer_status, :status => code.to_s
-      assert_equal message, @response.message
-    end
-  end
-
-  def test_head_with_string_status
-    get :head_with_string_status, :status => "404 Eat Dirt"
-    assert_equal 404, @response.response_code
-    assert_equal "Not Found", @response.message
-    assert_response :not_found
-  end
-
-  def test_head_with_status_code_first
-    get :head_with_status_code_first
-    assert_equal 403, @response.response_code
-    assert_equal "Forbidden", @response.message
-    assert_equal "something", @response.headers["X-Custom-Header"]
-    assert_response :forbidden
-  end
-
-  def test_using_layout_around_block
-    get :render_using_layout_around_block
-    assert_equal "Before (David)\nInside from block\nAfter", @response.body
-  end
-
-  def test_using_layout_around_block_in_main_layout_and_within_content_for_layout
-    get :render_using_layout_around_block_in_main_layout_and_within_content_for_layout
-    assert_equal "Before (Anthony)\nInside from first block in layout\nAfter\nBefore (David)\nInside from block\nAfter\nBefore (Ramm)\nInside from second block in layout\nAfter\n", @response.body
-  end
-
-  def test_partial_only
-    get :partial_only
-    assert_equal "only partial", @response.body
-    assert_equal "text/html", @response.content_type
-  end
-
-  def test_should_render_html_formatted_partial
-    get :partial
-    assert_equal "partial html", @response.body
-    assert_equal "text/html", @response.content_type
-  end
-
-  def test_render_html_formatted_partial_even_with_other_mime_time_in_accept
-    @request.accept = "text/javascript, text/html"
-
-    get :partial_html_erb
-
-    assert_equal "partial.html.erb", @response.body.strip
-    assert_equal "text/html", @response.content_type
-  end
-
-  def test_should_render_html_partial_with_formats
-    get :partial_formats_html
-    assert_equal "partial html", @response.body
-    assert_equal "text/html", @response.content_type
-  end
-
-  def test_render_to_string_partial
-    get :render_to_string_with_partial
-    assert_equal "only partial", assigns(:partial_only)
-    assert_equal "Hello: david", assigns(:partial_with_locals)
-    assert_equal "text/html", @response.content_type
-  end
-
-  def test_render_to_string_with_template_and_html_partial
-    get :render_to_string_with_template_and_html_partial
-    assert_equal "**only partial**\n", assigns(:text)
-    assert_equal "<strong>only partial</strong>\n", assigns(:html)
-    assert_equal "<strong>only html partial</strong>\n", @response.body
-    assert_equal "text/html", @response.content_type
-  end
-
-  def test_render_to_string_and_render_with_different_formats
-    get :render_to_string_and_render_with_different_formats
-    assert_equal "<strong>only partial</strong>\n", assigns(:html)
-    assert_equal "**only partial**\n", @response.body
-    assert_equal "text/plain", @response.content_type
-  end
-
-  def test_render_template_within_a_template_with_other_format
-    get :render_template_within_a_template_with_other_format
-    expected = "only html partial<p>This is grand!</p>"
-    assert_equal expected, @response.body.strip
-    assert_equal "text/html", @response.content_type
-  end
-
-  def test_partial_with_counter
-    get :partial_with_counter
-    assert_equal "5", @response.body
-  end
-
-  def test_partial_with_locals
-    get :partial_with_locals
-    assert_equal "Hello: david", @response.body
-  end
-
-  def test_partial_with_form_builder
-    get :partial_with_form_builder
-    assert_match(/<label/, @response.body)
-    assert_template('test/_form')
-  end
-
-  def test_partial_with_form_builder_subclass
-    get :partial_with_form_builder_subclass
-    assert_match(/<label/, @response.body)
-    assert_template('test/_labelling_form')
-  end
-
-  def test_nested_partial_with_form_builder
-    @controller = Fun::GamesController.new
-    get :nested_partial_with_form_builder
-    assert_match(/<label/, @response.body)
-    assert_template('fun/games/_form')
-  end
-
-  def test_namespaced_object_partial
-    @controller = Quiz::QuestionsController.new
-    get :new
-    assert_equal "Namespaced Partial", @response.body
-  end
-
-  def test_partial_collection
-    get :partial_collection
-    assert_equal "Hello: davidHello: mary", @response.body
-  end
-
-  def test_partial_collection_with_as
-    get :partial_collection_with_as
-    assert_equal "david david davidmary mary mary", @response.body
-  end
-
-  def test_partial_collection_with_counter
-    get :partial_collection_with_counter
-    assert_equal "david0mary1", @response.body
-  end
-
-  def test_partial_collection_with_as_and_counter
-    get :partial_collection_with_as_and_counter
-    assert_equal "david0mary1", @response.body
-  end
-
-  def test_partial_collection_with_locals
-    get :partial_collection_with_locals
-    assert_equal "Bonjour: davidBonjour: mary", @response.body
-  end
-
-  def test_locals_option_to_assert_template_is_not_supported
-    get :partial_collection_with_locals
-
-    warning_buffer = StringIO.new
-    $stderr = warning_buffer
-
-    assert_template partial: 'customer_greeting', locals: { greeting: 'Bonjour' }
-    assert_equal "the :locals option to #assert_template is only supported in a ActionView::TestCase\n", warning_buffer.string
-  ensure
-    $stderr = STDERR
-  end
-
-  def test_partial_collection_with_spacer
-    get :partial_collection_with_spacer
-    assert_equal "Hello: davidonly partialHello: mary", @response.body
-    assert_template :partial => '_customer'
-  end
-
-  def test_partial_collection_with_spacer_which_uses_render
-    get :partial_collection_with_spacer_which_uses_render
-    assert_equal "Hello: davidpartial html\npartial with partial\nHello: mary", @response.body
-    assert_template :partial => '_customer'
-  end
-
-  def test_partial_collection_shorthand_with_locals
-    get :partial_collection_shorthand_with_locals
-    assert_equal "Bonjour: davidBonjour: mary", @response.body
-    assert_template :partial => 'customers/_customer', :count => 2
-    assert_template :partial => '_completely_fake_and_made_up_template_that_cannot_possibly_be_rendered', :count => 0
-  end
-
-  def test_partial_collection_shorthand_with_different_types_of_records
-    get :partial_collection_shorthand_with_different_types_of_records
-    assert_equal "Bonjour bad customer: mark0Bonjour good customer: craig1Bonjour bad customer: john2Bonjour good customer: zach3Bonjour good customer: brandon4Bonjour bad customer: dan5", @response.body
-    assert_template :partial => 'good_customers/_good_customer', :count => 3
-    assert_template :partial => 'bad_customers/_bad_customer', :count => 3
-  end
-
-  def test_empty_partial_collection
-    get :empty_partial_collection
-    assert_equal " ", @response.body
-    assert_template :partial => false
-  end
-
-  def test_partial_with_hash_object
-    get :partial_with_hash_object
-    assert_equal "Sam\nmaS\n", @response.body
-  end
-
-  def test_partial_with_nested_object
-    get :partial_with_nested_object
-    assert_equal "first", @response.body
-  end
-
-  def test_partial_with_nested_object_shorthand
-    get :partial_with_nested_object_shorthand
-    assert_equal "first", @response.body
-  end
-
-  def test_hash_partial_collection
-    get :partial_hash_collection
-    assert_equal "Pratik\nkitarP\nAmy\nymA\n", @response.body
-  end
-
-  def test_partial_hash_collection_with_locals
-    get :partial_hash_collection_with_locals
-    assert_equal "Hola: PratikHola: Amy", @response.body
-  end
-
-  def test_render_missing_partial_template
-    assert_raise(ActionView::MissingTemplate) do
-      get :missing_partial
-    end
-  end
-
-  def test_render_call_to_partial_with_layout
-    get :render_call_to_partial_with_layout
-    assert_equal "Before (David)\nInside from partial (David)\nAfter", @response.body
-  end
-
-  def test_render_call_to_partial_with_layout_in_main_layout_and_within_content_for_layout
-    get :render_call_to_partial_with_layout_in_main_layout_and_within_content_for_layout
-    assert_equal "Before (Anthony)\nInside from partial (Anthony)\nAfter\nBefore (David)\nInside from partial (David)\nAfter\nBefore (Ramm)\nInside from partial (Ramm)\nAfter", @response.body
-  end
-end
-
 class ExpiresInRenderTest < ActionController::TestCase
   tests TestController
 
-  def setup
-    @request.host = "www.nextangle.com"
-  end
-
   def test_expires_in_header
     get :conditional_hello_with_expires_in
     assert_equal "max-age=60, private", @response.headers["Cache-Control"]
@@ -1592,7 +305,6 @@ class LastModifiedRenderTest < ActionController::TestCase
 
   def setup
     super
-    @request.host = "www.nextangle.com"
     @last_modified = Time.now.utc.beginning_of_day.httpdate
   end
 
@@ -1677,7 +389,6 @@ class EtagRenderTest < ActionController::TestCase
 
   def setup
     super
-    @request.host = "www.nextangle.com"
   end
 
   def test_multiple_etags
@@ -1705,7 +416,6 @@ class EtagRenderTest < ActionController::TestCase
   end
 end
 
-
 class MetalRenderTest < ActionController::TestCase
   tests MetalTestController
 
@@ -1714,3 +424,109 @@ class MetalRenderTest < ActionController::TestCase
     assert_equal "NilClass", @response.body
   end
 end
+
+class HeadRenderTest < ActionController::TestCase
+  tests TestController
+
+  def setup
+    @request.host = "www.nextangle.com"
+  end
+
+  def test_head_created
+    post :head_created
+    assert @response.body.blank?
+    assert_response :created
+  end
+
+  def test_head_created_with_application_json_content_type
+    post :head_created_with_application_json_content_type
+    assert @response.body.blank?
+    assert_equal "application/json", @response.header["Content-Type"]
+    assert_response :created
+  end
+
+  def test_head_ok_with_image_png_content_type
+    post :head_ok_with_image_png_content_type
+    assert @response.body.blank?
+    assert_equal "image/png", @response.header["Content-Type"]
+    assert_response :ok
+  end
+
+  def test_head_with_location_header
+    get :head_with_location_header
+    assert @response.body.blank?
+    assert_equal "/foo", @response.headers["Location"]
+    assert_response :ok
+  end
+
+  def test_head_with_location_object
+    with_routing do |set|
+      set.draw do
+        resources :customers
+        get ':controller/:action'
+      end
+
+      get :head_with_location_object
+      assert @response.body.blank?
+      assert_equal "http://www.nextangle.com/customers/1", @response.headers["Location"]
+      assert_response :ok
+    end
+  end
+
+  def test_head_with_custom_header
+    get :head_with_custom_header
+    assert @response.body.blank?
+    assert_equal "something", @response.headers["X-Custom-Header"]
+    assert_response :ok
+  end
+
+  def test_head_with_www_authenticate_header
+    get :head_with_www_authenticate_header
+    assert @response.body.blank?
+    assert_equal "something", @response.headers["WWW-Authenticate"]
+    assert_response :ok
+  end
+
+  def test_head_with_symbolic_status
+    get :head_with_symbolic_status, :status => "ok"
+    assert_equal 200, @response.status
+    assert_response :ok
+
+    get :head_with_symbolic_status, :status => "not_found"
+    assert_equal 404, @response.status
+    assert_response :not_found
+
+    get :head_with_symbolic_status, :status => "no_content"
+    assert_equal 204, @response.status
+    assert !@response.headers.include?('Content-Length')
+    assert_response :no_content
+
+    Rack::Utils::SYMBOL_TO_STATUS_CODE.each do |status, code|
+      get :head_with_symbolic_status, :status => status.to_s
+      assert_equal code, @response.response_code
+      assert_response status
+    end
+  end
+
+  def test_head_with_integer_status
+    Rack::Utils::HTTP_STATUS_CODES.each do |code, message|
+      get :head_with_integer_status, :status => code.to_s
+      assert_equal message, @response.message
+    end
+  end
+
+  def test_head_with_string_status
+    get :head_with_string_status, :status => "404 Eat Dirt"
+    assert_equal 404, @response.response_code
+    assert_equal "Not Found", @response.message
+    assert_response :not_found
+  end
+
+  def test_head_with_status_code_first
+    get :head_with_status_code_first
+    assert_equal 403, @response.response_code
+    assert_equal "Forbidden", @response.message
+    assert_equal "something", @response.headers["X-Custom-Header"]
+    assert_response :forbidden
+  end
+end
diff --git a/actionpack/test/controller/request_forgery_protection_test.rb b/actionpack/test/controller/request_forgery_protection_test.rb
index c272e785c2..1f5fc06410 100644
--- a/actionpack/test/controller/request_forgery_protection_test.rb
+++ b/actionpack/test/controller/request_forgery_protection_test.rb
@@ -52,18 +52,36 @@ module RequestForgeryProtectionActions
     render :inline => "<%= form_for(:some_resource, :remote => true, :authenticity_token => 'external_token') {} %>"
   end
 
+  def same_origin_js
+    render js: 'foo();'
+  end
+
+  def negotiate_same_origin
+    respond_to do |format|
+      format.js { same_origin_js }
+    end
+  end
+
+  def cross_origin_js
+    same_origin_js
+  end
+
+  def negotiate_cross_origin
+    negotiate_same_origin
+  end
+
   def rescue_action(e) raise e end
 end
 
 # sample controllers
 class RequestForgeryProtectionControllerUsingResetSession < ActionController::Base
   include RequestForgeryProtectionActions
-  protect_from_forgery :only => %w(index meta), :with => :reset_session
+  protect_from_forgery :only => %w(index meta same_origin_js negotiate_same_origin), :with => :reset_session
 end
 
 class RequestForgeryProtectionControllerUsingException < ActionController::Base
   include RequestForgeryProtectionActions
-  protect_from_forgery :only => %w(index meta), :with => :exception
+  protect_from_forgery :only => %w(index meta same_origin_js negotiate_same_origin), :with => :exception
 end
 
 class RequestForgeryProtectionControllerUsingNullSession < ActionController::Base
@@ -78,6 +96,11 @@ class RequestForgeryProtectionControllerUsingNullSession < ActionController::Bas
     cookies.encrypted[:foo] = 'bar'
     render :nothing => true
   end
+
+  def try_to_reset_session
+    reset_session
+    render :nothing => true
+  end
 end
 
 class FreeCookieController < RequestForgeryProtectionControllerUsingResetSession
@@ -196,7 +219,7 @@ module RequestForgeryProtectionTests
   end
 
   def test_should_not_allow_post_without_token_irrespective_of_format
-    assert_blocked { post :index, :format=>'xml' }
+    assert_blocked { post :index, format: 'xml' }
   end
 
   def test_should_not_allow_patch_without_token
@@ -266,6 +289,48 @@ module RequestForgeryProtectionTests
     end
   end
 
+  def test_should_only_allow_same_origin_js_get_with_xhr_header
+    assert_cross_origin_blocked { get :same_origin_js }
+    assert_cross_origin_blocked { get :same_origin_js, format: 'js' }
+    assert_cross_origin_blocked do
+      @request.accept = 'text/javascript'
+      get :negotiate_same_origin
+    end
+
+    assert_cross_origin_not_blocked { xhr :get, :same_origin_js }
+    assert_cross_origin_not_blocked { xhr :get, :same_origin_js, format: 'js' }
+    assert_cross_origin_not_blocked do
+      @request.accept = 'text/javascript'
+      xhr :get, :negotiate_same_origin
+    end
+  end
+
+  # Allow non-GET requests since GET is all a remote <script> tag can muster.
+  def test_should_allow_non_get_js_without_xhr_header
+    assert_cross_origin_not_blocked { post :same_origin_js, custom_authenticity_token: @token }
+    assert_cross_origin_not_blocked { post :same_origin_js, format: 'js', custom_authenticity_token: @token }
+    assert_cross_origin_not_blocked do
+      @request.accept = 'text/javascript'
+      post :negotiate_same_origin, custom_authenticity_token: @token
+    end
+  end
+
+  def test_should_only_allow_cross_origin_js_get_without_xhr_header_if_protection_disabled
+    assert_cross_origin_not_blocked { get :cross_origin_js }
+    assert_cross_origin_not_blocked { get :cross_origin_js, format: 'js' }
+    assert_cross_origin_not_blocked do
+      @request.accept = 'text/javascript'
+      get :negotiate_cross_origin
+    end
+
+    assert_cross_origin_not_blocked { xhr :get, :cross_origin_js }
+    assert_cross_origin_not_blocked { xhr :get, :cross_origin_js, format: 'js' }
+    assert_cross_origin_not_blocked do
+      @request.accept = 'text/javascript'
+      xhr :get, :negotiate_cross_origin
+    end
+  end
+
   def assert_blocked
     session[:something_like_user_id] = 1
     yield
@@ -277,6 +342,16 @@ module RequestForgeryProtectionTests
     assert_nothing_raised { yield }
     assert_response :success
   end
+
+  def assert_cross_origin_blocked
+    assert_raises(ActionController::InvalidCrossOriginRequest) do
+      yield
+    end
+  end
+
+  def assert_cross_origin_not_blocked
+    assert_not_blocked { yield }
+  end
 end
 
 # OK let's get our test on
@@ -300,13 +375,13 @@ class RequestForgeryProtectionControllerUsingResetSessionTest < ActionController
   end
 end
 
-class NullSessionDummyKeyGenerator
-  def generate_key(secret)
-    '03312270731a2ed0d11ed091c2338a06'
+class RequestForgeryProtectionControllerUsingNullSessionTest < ActionController::TestCase
+  class NullSessionDummyKeyGenerator
+    def generate_key(secret)
+      '03312270731a2ed0d11ed091c2338a06'
+    end
   end
-end
 
-class RequestForgeryProtectionControllerUsingNullSessionTest < ActionController::TestCase  
   def setup
     @request.env[ActionDispatch::Cookies::GENERATOR_KEY] = NullSessionDummyKeyGenerator.new
   end
@@ -320,6 +395,11 @@ class RequestForgeryProtectionControllerUsingNullSessionTest < ActionController:
     post :encrypted
     assert_response :ok
   end
+
+  test 'should allow reset_session' do
+    post :try_to_reset_session
+    assert_response :ok
+  end
 end
 
 class RequestForgeryProtectionControllerUsingExceptionTest < ActionController::TestCase
@@ -365,8 +445,8 @@ end
 
 class CustomAuthenticityParamControllerTest < ActionController::TestCase
   def setup
-    ActionController::Base.request_forgery_protection_token = :custom_token_name
     super
+    ActionController::Base.request_forgery_protection_token = :custom_token_name
   end
 
   def teardown
diff --git a/actionpack/test/controller/resources_test.rb b/actionpack/test/controller/resources_test.rb
index 9aea7e860a..a5f43c4b6b 100644
--- a/actionpack/test/controller/resources_test.rb
+++ b/actionpack/test/controller/resources_test.rb
@@ -4,6 +4,7 @@ require 'active_support/core_ext/object/with_options'
 require 'active_support/core_ext/array/extract_options'
 
 class ResourcesTest < ActionController::TestCase
+
   def test_default_restful_routes
     with_restful_routing :messages do
       assert_simply_restful_for :messages
@@ -1004,7 +1005,7 @@ class ResourcesTest < ActionController::TestCase
         end
       end
 
-      assert_resource_allowed_routes('images', { :product_id => '1' },                    { :id => '2' }, [:index, :new, :create, :show, :edit, :update, :destory], [], 'products/1/images')
+      assert_resource_allowed_routes('images', { :product_id => '1' },                    { :id => '2' }, [:index, :new, :create, :show, :edit, :update, :destroy], [], 'products/1/images')
       assert_resource_allowed_routes('images', { :product_id => '1', :format => 'xml' },  { :id => '2' }, [:index, :new, :create, :show, :edit, :update, :destroy], [], 'products/1/images')
     end
   end
@@ -1320,6 +1321,8 @@ class ResourcesTest < ActionController::TestCase
         assert_recognizes options, path_options
       elsif Array(not_allowed).include?(action)
         assert_not_recognizes options, path_options
+      else
+        raise Assertion, 'Invalid Action has passed'
       end
     end
 
diff --git a/actionpack/test/controller/routing_test.rb b/actionpack/test/controller/routing_test.rb
index f735564305..df453a0251 100644
--- a/actionpack/test/controller/routing_test.rb
+++ b/actionpack/test/controller/routing_test.rb
@@ -2,6 +2,7 @@
 require 'abstract_unit'
 require 'controller/fake_controllers'
 require 'active_support/core_ext/object/with_options'
+require 'active_support/core_ext/object/json'
 
 class MilestonesController < ActionController::Base
   def index() head :ok end
@@ -86,36 +87,36 @@ class LegacyRouteSetTests < ActiveSupport::TestCase
   def test_symbols_with_dashes
     rs.draw do
       get '/:artist/:song-omg', :to => lambda { |env|
-        resp = JSON.dump env[ActionDispatch::Routing::RouteSet::PARAMETERS_KEY]
+        resp = ActiveSupport::JSON.encode env[ActionDispatch::Routing::RouteSet::PARAMETERS_KEY]
         [200, {}, [resp]]
       }
     end
 
-    hash = JSON.load get(URI('http://example.org/journey/faithfully-omg'))
+    hash = ActiveSupport::JSON.decode get(URI('http://example.org/journey/faithfully-omg'))
     assert_equal({"artist"=>"journey", "song"=>"faithfully"}, hash)
   end
 
   def test_id_with_dash
     rs.draw do
       get '/journey/:id', :to => lambda { |env|
-        resp = JSON.dump env[ActionDispatch::Routing::RouteSet::PARAMETERS_KEY]
+        resp = ActiveSupport::JSON.encode env[ActionDispatch::Routing::RouteSet::PARAMETERS_KEY]
         [200, {}, [resp]]
       }
     end
 
-    hash = JSON.load get(URI('http://example.org/journey/faithfully-omg'))
+    hash = ActiveSupport::JSON.decode get(URI('http://example.org/journey/faithfully-omg'))
     assert_equal({"id"=>"faithfully-omg"}, hash)
   end
 
   def test_dash_with_custom_regexp
     rs.draw do
       get '/:artist/:song-omg', :constraints => { :song => /\d+/ }, :to => lambda { |env|
-        resp = JSON.dump env[ActionDispatch::Routing::RouteSet::PARAMETERS_KEY]
+        resp = ActiveSupport::JSON.encode env[ActionDispatch::Routing::RouteSet::PARAMETERS_KEY]
         [200, {}, [resp]]
       }
     end
 
-    hash = JSON.load get(URI('http://example.org/journey/123-omg'))
+    hash = ActiveSupport::JSON.decode get(URI('http://example.org/journey/123-omg'))
     assert_equal({"artist"=>"journey", "song"=>"123"}, hash)
     assert_equal 'Not Found', get(URI('http://example.org/journey/faithfully-omg'))
   end
@@ -123,24 +124,24 @@ class LegacyRouteSetTests < ActiveSupport::TestCase
   def test_pre_dash
     rs.draw do
       get '/:artist/omg-:song', :to => lambda { |env|
-        resp = JSON.dump env[ActionDispatch::Routing::RouteSet::PARAMETERS_KEY]
+        resp = ActiveSupport::JSON.encode env[ActionDispatch::Routing::RouteSet::PARAMETERS_KEY]
         [200, {}, [resp]]
       }
     end
 
-    hash = JSON.load get(URI('http://example.org/journey/omg-faithfully'))
+    hash = ActiveSupport::JSON.decode get(URI('http://example.org/journey/omg-faithfully'))
     assert_equal({"artist"=>"journey", "song"=>"faithfully"}, hash)
   end
 
   def test_pre_dash_with_custom_regexp
     rs.draw do
       get '/:artist/omg-:song', :constraints => { :song => /\d+/ }, :to => lambda { |env|
-        resp = JSON.dump env[ActionDispatch::Routing::RouteSet::PARAMETERS_KEY]
+        resp = ActiveSupport::JSON.encode env[ActionDispatch::Routing::RouteSet::PARAMETERS_KEY]
         [200, {}, [resp]]
       }
     end
 
-    hash = JSON.load get(URI('http://example.org/journey/omg-123'))
+    hash = ActiveSupport::JSON.decode get(URI('http://example.org/journey/omg-123'))
     assert_equal({"artist"=>"journey", "song"=>"123"}, hash)
     assert_equal 'Not Found', get(URI('http://example.org/journey/omg-faithfully'))
   end
@@ -160,14 +161,14 @@ class LegacyRouteSetTests < ActiveSupport::TestCase
   def test_star_paths_are_greedy_but_not_too_much
     rs.draw do
       get "/*path", :to => lambda { |env|
-        x = JSON.dump env["action_dispatch.request.path_parameters"]
+        x = ActiveSupport::JSON.encode env["action_dispatch.request.path_parameters"]
         [200, {}, [x]]
       }
     end
 
     expected = { "path" => "foo/bar", "format" => "html" }
     u = URI('http://example.org/foo/bar.html')
-    assert_equal expected, JSON.parse(get(u))
+    assert_equal expected, ActiveSupport::JSON.decode(get(u))
   end
 
   def test_optional_star_paths_are_greedy
@@ -185,7 +186,7 @@ class LegacyRouteSetTests < ActiveSupport::TestCase
   def test_optional_star_paths_are_greedy_but_not_too_much
     rs.draw do
       get "/(*filters)", :to => lambda { |env|
-        x = JSON.dump env["action_dispatch.request.path_parameters"]
+        x = ActiveSupport::JSON.encode env["action_dispatch.request.path_parameters"]
         [200, {}, [x]]
       }
     end
@@ -193,7 +194,7 @@ class LegacyRouteSetTests < ActiveSupport::TestCase
     expected = { "filters" => "ne_27.065938,-80.6092/sw_25.489856,-82",
                  "format"  => "542794" }
     u = URI('http://example.org/ne_27.065938,-80.6092/sw_25.489856,-82.542794')
-    assert_equal expected, JSON.parse(get(u))
+    assert_equal expected, ActiveSupport::JSON.decode(get(u))
   end
 
   def test_regexp_precidence
@@ -1832,11 +1833,11 @@ class RackMountIntegrationTests < ActiveSupport::TestCase
     assert_equal({:controller => 'foo', :action => 'id_default', :id => 1 }, @routes.recognize_path('/id_default'))
     assert_equal({:controller => 'foo', :action => 'get_or_post'}, @routes.recognize_path('/get_or_post', :method => :get))
     assert_equal({:controller => 'foo', :action => 'get_or_post'}, @routes.recognize_path('/get_or_post', :method => :post))
-    assert_raise(ActionController::ActionControllerError) { @routes.recognize_path('/get_or_post', :method => :put) }
-    assert_raise(ActionController::ActionControllerError) { @routes.recognize_path('/get_or_post', :method => :delete) }
+    assert_raise(ActionController::RoutingError) { @routes.recognize_path('/get_or_post', :method => :put) }
+    assert_raise(ActionController::RoutingError) { @routes.recognize_path('/get_or_post', :method => :delete) }
 
     assert_equal({:controller => 'posts', :action => 'index', :optional => 'bar'}, @routes.recognize_path('/optional/bar'))
-    assert_raise(ActionController::ActionControllerError) { @routes.recognize_path('/optional') }
+    assert_raise(ActionController::RoutingError) { @routes.recognize_path('/optional') }
 
     assert_equal({:controller => 'posts', :action => 'show', :id => '1', :ws => true}, @routes.recognize_path('/ws/posts/show/1', :method => :get))
     assert_equal({:controller => 'posts', :action => 'list', :ws => true}, @routes.recognize_path('/ws/posts/list', :method => :get))
@@ -1904,6 +1905,10 @@ class RackMountIntegrationTests < ActiveSupport::TestCase
     assert_equal({:controller => 'news', :action => 'index'}, @routes.recognize_path(URI.parser.escape('こんにちは/世界'), :method => :get))
   end
 
+  def test_downcased_unicode_path
+    assert_equal({:controller => 'news', :action => 'index'}, @routes.recognize_path(URI.parser.escape('こんにちは/世界').downcase, :method => :get))
+  end
+
   private
     def sort_extras!(extras)
       if extras.length == 2
@@ -1911,11 +1916,4 @@ class RackMountIntegrationTests < ActiveSupport::TestCase
       end
       extras
     end
-
-    def assert_raise(e)
-      result = yield
-      flunk "Did not raise #{e}, but returned #{result.inspect}"
-    rescue e
-      assert true
-    end
 end
diff --git a/actionpack/test/controller/send_file_test.rb b/actionpack/test/controller/send_file_test.rb
index 8ecc1c7d73..4df2f8b98d 100644
--- a/actionpack/test/controller/send_file_test.rb
+++ b/actionpack/test/controller/send_file_test.rb
@@ -25,6 +25,10 @@ class SendFileController < ActionController::Base
   end
 end
 
+class SendFileWithActionControllerLive < SendFileController
+  include ActionController::Live
+end
+
 class SendFileTest < ActionController::TestCase
   tests SendFileController
   include TestFileUtils
@@ -144,7 +148,7 @@ class SendFileTest < ActionController::TestCase
     }
 
     @controller.headers = {}
-    assert !@controller.send(:send_file_headers!, options)
+    assert_raise(ArgumentError) { @controller.send(:send_file_headers!, options) }
   end
 
   def test_send_file_headers_guess_type_from_extension
@@ -196,4 +200,14 @@ class SendFileTest < ActionController::TestCase
       assert_equal 200, @response.status
     end
   end
+
+  tests SendFileWithActionControllerLive
+
+  def test_send_file_with_action_controller_live
+    @controller = SendFileWithActionControllerLive.new
+    @controller.options = { :content_type => "application/x-ruby" }
+
+    response = process('file')
+    assert_equal 200, response.status
+  end
 end
diff --git a/actionpack/test/controller/test_case_test.rb b/actionpack/test/controller/test_case_test.rb
index 7c27458f46..de0476dbde 100644
--- a/actionpack/test/controller/test_case_test.rb
+++ b/actionpack/test/controller/test_case_test.rb
@@ -1,5 +1,6 @@
 require 'abstract_unit'
 require 'controller/fake_controllers'
+require 'active_support/json/decoding'
 
 class TestCaseTest < ActionController::TestCase
   class TestController < ActionController::Base
@@ -280,13 +281,6 @@ XML
     assert_equal "/test_case_test/test/test_uri/7", @response.body
   end
 
-  def test_process_with_old_api
-    assert_deprecated do
-      process :test_uri, :id => 7
-      assert_equal "/test_case_test/test/test_uri/7", @response.body
-    end
-  end
-
   def test_process_with_request_uri_with_params_with_explicit_uri
     @request.env['PATH_INFO'] = "/explicit/uri"
     process :test_uri, "GET", :id => 7
@@ -629,7 +623,7 @@ XML
     @request.headers['Referer'] = "http://nohost.com/home"
     @request.headers['Content-Type'] = "application/rss+xml"
     get :test_headers
-    parsed_env = JSON.parse(@response.body)
+    parsed_env = ActiveSupport::JSON.decode(@response.body)
     assert_equal "http://nohost.com/home", parsed_env["HTTP_REFERER"]
     assert_equal "application/rss+xml", parsed_env["CONTENT_TYPE"]
   end
@@ -638,7 +632,7 @@ XML
     @request.headers['HTTP_REFERER'] = "http://example.com/about"
     @request.headers['CONTENT_TYPE'] = "application/json"
     get :test_headers
-    parsed_env = JSON.parse(@response.body)
+    parsed_env = ActiveSupport::JSON.decode(@response.body)
     assert_equal "http://example.com/about", parsed_env["HTTP_REFERER"]
     assert_equal "application/json", parsed_env["CONTENT_TYPE"]
   end
diff --git a/actionpack/test/controller/url_for_test.rb b/actionpack/test/controller/url_for_test.rb
index 088ad73f2f..d2b4952759 100644
--- a/actionpack/test/controller/url_for_test.rb
+++ b/actionpack/test/controller/url_for_test.rb
@@ -370,6 +370,24 @@ module AbstractController
         assert_equal("/c/a?show=false", W.new.url_for(:only_path => true, :controller => 'c', :action => 'a', :show => false))
       end
 
+      def test_url_generation_with_array_and_hash
+        with_routing do |set|
+          set.draw do
+            namespace :admin do
+              resources :posts
+            end
+          end
+
+          kls = Class.new { include set.url_helpers }
+          kls.default_url_options[:host] = 'www.basecamphq.com'
+
+          controller = kls.new
+          assert_equal("http://www.basecamphq.com/admin/posts/new?param=value",
+            controller.send(:url_for, [:new, :admin, :post, { param: 'value' }])
+          )
+        end
+      end
+
       private
         def extract_params(url)
           url.split('?', 2).last.split('&').sort
diff --git a/actionpack/test/controller/view_paths_test.rb b/actionpack/test/controller/view_paths_test.rb
deleted file mode 100644
index c6e7a523b9..0000000000
--- a/actionpack/test/controller/view_paths_test.rb
+++ /dev/null
@@ -1,174 +0,0 @@
-require 'abstract_unit'
-
-class ViewLoadPathsTest < ActionController::TestCase
-  class TestController < ActionController::Base
-    def self.controller_path() "test" end
-
-    before_action :add_view_path, only: :hello_world_at_request_time
-
-    def hello_world() end
-    def hello_world_at_request_time() render(:action => 'hello_world') end
-
-    private
-      def add_view_path
-        prepend_view_path "#{FIXTURE_LOAD_PATH}/override"
-      end
-  end
-
-  module Test
-    class SubController < ActionController::Base
-      layout 'test/sub'
-      def hello_world; render(:template => 'test/hello_world'); end
-    end
-  end
-
-  def setup
-    @request  = ActionController::TestRequest.new
-    @response = ActionController::TestResponse.new
-    @controller = TestController.new
-    @paths = TestController.view_paths
-  end
-
-  def teardown
-    TestController.view_paths = @paths
-  end
-
-  def expand(array)
-    array.map {|x| File.expand_path(x.to_s)}
-  end
-
-  def assert_paths(*paths)
-    controller = paths.first.is_a?(Class) ? paths.shift : @controller
-    assert_equal expand(paths), controller.view_paths.map { |p| p.to_s }
-  end
-
-  def test_template_load_path_was_set_correctly
-    assert_paths FIXTURE_LOAD_PATH
-  end
-
-  def test_controller_appends_view_path_correctly
-    @controller.append_view_path 'foo'
-    assert_paths(FIXTURE_LOAD_PATH, "foo")
-
-    @controller.append_view_path(%w(bar baz))
-    assert_paths(FIXTURE_LOAD_PATH, "foo", "bar", "baz")
-
-    @controller.append_view_path(FIXTURE_LOAD_PATH)
-    assert_paths(FIXTURE_LOAD_PATH, "foo", "bar", "baz", FIXTURE_LOAD_PATH)
-  end
-
-  def test_controller_prepends_view_path_correctly
-    @controller.prepend_view_path 'baz'
-    assert_paths("baz", FIXTURE_LOAD_PATH)
-
-    @controller.prepend_view_path(%w(foo bar))
-    assert_paths "foo", "bar", "baz", FIXTURE_LOAD_PATH
-
-    @controller.prepend_view_path(FIXTURE_LOAD_PATH)
-    assert_paths FIXTURE_LOAD_PATH, "foo", "bar", "baz", FIXTURE_LOAD_PATH
-  end
-
-  def test_template_appends_view_path_correctly
-    @controller.instance_variable_set :@template, ActionView::Base.new(TestController.view_paths, {}, @controller)
-    class_view_paths = TestController.view_paths
-
-    @controller.append_view_path 'foo'
-    assert_paths FIXTURE_LOAD_PATH, "foo"
-
-    @controller.append_view_path(%w(bar baz))
-    assert_paths FIXTURE_LOAD_PATH, "foo", "bar", "baz"
-    assert_paths TestController, *class_view_paths
-  end
-
-  def test_template_prepends_view_path_correctly
-    @controller.instance_variable_set :@template, ActionView::Base.new(TestController.view_paths, {}, @controller)
-    class_view_paths = TestController.view_paths
-
-    @controller.prepend_view_path 'baz'
-    assert_paths "baz", FIXTURE_LOAD_PATH
-
-    @controller.prepend_view_path(%w(foo bar))
-    assert_paths "foo", "bar", "baz", FIXTURE_LOAD_PATH
-    assert_paths TestController, *class_view_paths
-  end
-
-  def test_view_paths
-    get :hello_world
-    assert_response :success
-    assert_equal "Hello world!", @response.body
-  end
-
-  def test_view_paths_override
-    TestController.prepend_view_path "#{FIXTURE_LOAD_PATH}/override"
-    get :hello_world
-    assert_response :success
-    assert_equal "Hello overridden world!", @response.body
-  end
-
-  def test_view_paths_override_for_layouts_in_controllers_with_a_module
-    @controller = Test::SubController.new
-    Test::SubController.view_paths = [ "#{FIXTURE_LOAD_PATH}/override", FIXTURE_LOAD_PATH, "#{FIXTURE_LOAD_PATH}/override2" ]
-    get :hello_world
-    assert_response :success
-    assert_equal "layout: Hello overridden world!", @response.body
-  end
-
-  def test_view_paths_override_at_request_time
-    get :hello_world_at_request_time
-    assert_response :success
-    assert_equal "Hello overridden world!", @response.body
-  end
-
-  def test_decorate_view_paths_with_custom_resolver
-    decorator_class = Class.new(ActionView::PathResolver) do
-      def initialize(path_set)
-        @path_set = path_set
-      end
-
-      def find_all(*args)
-        @path_set.find_all(*args).collect do |template|
-          ::ActionView::Template.new(
-            "Decorated body",
-            template.identifier,
-            template.handler,
-            {
-              :virtual_path => template.virtual_path,
-              :format => template.formats
-            }
-          )
-        end
-      end
-    end
-
-    decorator = decorator_class.new(TestController.view_paths)
-    TestController.view_paths = ActionView::PathSet.new.push(decorator)
-
-    get :hello_world
-    assert_response :success
-    assert_equal "Decorated body", @response.body
-  end
-
-  def test_inheritance
-    original_load_paths = ActionController::Base.view_paths
-
-    self.class.class_eval %{
-      class A < ActionController::Base; end
-      class B < A; end
-      class C < ActionController::Base; end
-    }
-
-    A.view_paths = ['a/path']
-
-    assert_paths A, "a/path"
-    assert_paths A, *B.view_paths
-    assert_paths C, *original_load_paths
-
-    C.view_paths = []
-    assert_nothing_raised { C.append_view_path 'c/path' }
-    assert_paths C, "c/path"
-  end
-
-  def test_lookup_context_accessor
-    assert_equal ["test"], TestController.new.lookup_context.prefixes
-  end
-end
diff --git a/actionpack/test/controller/webservice_test.rb b/actionpack/test/controller/webservice_test.rb
index b2dfd96606..d80b0e2da0 100644
--- a/actionpack/test/controller/webservice_test.rb
+++ b/actionpack/test/controller/webservice_test.rb
@@ -1,4 +1,5 @@
 require 'abstract_unit'
+require 'active_support/json/decoding'
 
 class WebServiceTest < ActionDispatch::IntegrationTest
   class TestController < ActionController::Base
@@ -54,7 +55,7 @@ class WebServiceTest < ActionDispatch::IntegrationTest
 
   def test_register_and_use_json_simple
     with_test_route_set do
-      with_params_parsers Mime::JSON => Proc.new { |data| JSON.parse(data)['request'].with_indifferent_access } do
+      with_params_parsers Mime::JSON => Proc.new { |data| ActiveSupport::JSON.decode(data)['request'].with_indifferent_access } do
         post "/", '{"request":{"summary":"content...","title":"JSON"}}',
           'CONTENT_TYPE' => 'application/json'
 
diff --git a/actionpack/test/dispatch/debug_exceptions_test.rb b/actionpack/test/dispatch/debug_exceptions_test.rb
index ff0baccd76..3045a07ad6 100644
--- a/actionpack/test/dispatch/debug_exceptions_test.rb
+++ b/actionpack/test/dispatch/debug_exceptions_test.rb
@@ -128,6 +128,47 @@ class DebugExceptionsTest < ActionDispatch::IntegrationTest
     assert_match(/ActionController::ParameterMissing/, body)
   end
 
+  test "rescue with text error for xhr request" do
+    @app = DevelopmentApp
+    xhr_request_env = {'action_dispatch.show_exceptions' => true, 'HTTP_X_REQUESTED_WITH' => 'XMLHttpRequest'}
+
+    get "/", {}, xhr_request_env
+    assert_response 500
+    assert_no_match(/<body>/, body)
+    assert_equal response.content_type, "text/plain"
+    assert_match(/puke/, body)
+
+    get "/not_found", {}, xhr_request_env
+    assert_response 404
+    assert_no_match(/<body>/, body)
+    assert_equal response.content_type, "text/plain"
+    assert_match(/#{AbstractController::ActionNotFound.name}/, body)
+
+    get "/method_not_allowed", {}, xhr_request_env
+    assert_response 405
+    assert_no_match(/<body>/, body)
+    assert_equal response.content_type, "text/plain"
+    assert_match(/ActionController::MethodNotAllowed/, body)
+
+    get "/unknown_http_method", {}, xhr_request_env
+    assert_response 405
+    assert_no_match(/<body>/, body)
+    assert_equal response.content_type, "text/plain"
+    assert_match(/ActionController::UnknownHttpMethod/, body)
+
+    get "/bad_request", {}, xhr_request_env
+    assert_response 400
+    assert_no_match(/<body>/, body)
+    assert_equal response.content_type, "text/plain"
+    assert_match(/ActionController::BadRequest/, body)
+
+    get "/parameter_missing", {}, xhr_request_env
+    assert_response 400
+    assert_no_match(/<body>/, body)
+    assert_equal response.content_type, "text/plain"
+    assert_match(/ActionController::ParameterMissing/, body)
+  end
+
   test "does not show filtered parameters" do
     @app = DevelopmentApp
 
diff --git a/actionpack/test/dispatch/mime_type_test.rb b/actionpack/test/dispatch/mime_type_test.rb
index 6a2eb7da9f..981cf2426e 100644
--- a/actionpack/test/dispatch/mime_type_test.rb
+++ b/actionpack/test/dispatch/mime_type_test.rb
@@ -31,21 +31,21 @@ class MimeTypeTest < ActiveSupport::TestCase
 
   test "parse text with trailing star at the beginning" do
     accept = "text/*, text/html, application/json, multipart/form-data"
-    expect = [Mime::HTML, Mime::TEXT, Mime::JS, Mime::CSS, Mime::ICS, Mime::CSV, Mime::XML, Mime::YAML, Mime::JSON, Mime::MULTIPART_FORM]
+    expect = [Mime::HTML, Mime::TEXT, Mime::JS, Mime::CSS, Mime::ICS, Mime::CSV, Mime::VCF, Mime::XML, Mime::YAML, Mime::JSON, Mime::MULTIPART_FORM]
     parsed = Mime::Type.parse(accept)
     assert_equal expect, parsed
   end
 
   test "parse text with trailing star in the end" do
     accept = "text/html, application/json, multipart/form-data, text/*"
-    expect = [Mime::HTML, Mime::JSON, Mime::MULTIPART_FORM, Mime::TEXT, Mime::JS, Mime::CSS, Mime::ICS, Mime::CSV, Mime::XML, Mime::YAML]
+    expect = [Mime::HTML, Mime::JSON, Mime::MULTIPART_FORM, Mime::TEXT, Mime::JS, Mime::CSS, Mime::ICS, Mime::CSV, Mime::VCF, Mime::XML, Mime::YAML]
     parsed = Mime::Type.parse(accept)
     assert_equal expect, parsed
   end
 
   test "parse text with trailing star" do
     accept = "text/*"
-    expect = [Mime::HTML, Mime::TEXT, Mime::JS, Mime::CSS, Mime::ICS, Mime::CSV, Mime::XML, Mime::YAML, Mime::JSON]
+    expect = [Mime::HTML, Mime::TEXT, Mime::JS, Mime::CSS, Mime::ICS, Mime::CSV, Mime::VCF, Mime::XML, Mime::YAML, Mime::JSON]
     parsed = Mime::Type.parse(accept)
     assert_equal expect, parsed
   end
@@ -185,11 +185,6 @@ class MimeTypeTest < ActiveSupport::TestCase
     all_types.uniq!
     # Remove custom Mime::Type instances set in other tests, like Mime::GIF and Mime::IPHONE
     all_types.delete_if { |type| !Mime.const_defined?(type.upcase) }
-    assert_deprecated do
-      verified, unverified = all_types.partition { |type| Mime::Type.browser_generated_types.include? type }
-      assert verified.each   { |type| assert  Mime.const_get(type.upcase).verify_request?, "Verifiable Mime Type is not verified: #{type.inspect}" }
-      assert unverified.each { |type| assert !Mime.const_get(type.upcase).verify_request?, "Nonverifiable Mime Type is verified: #{type.inspect}" }
-    end
   end
 
   test "references gives preference to symbols before strings" do
diff --git a/actionpack/test/dispatch/mount_test.rb b/actionpack/test/dispatch/mount_test.rb
index e5e28c28be..683a4f01e2 100644
--- a/actionpack/test/dispatch/mount_test.rb
+++ b/actionpack/test/dispatch/mount_test.rb
@@ -5,7 +5,7 @@ class TestRoutingMount < ActionDispatch::IntegrationTest
 
   class FakeEngine
     def self.routes
-      Object.new
+      @routes ||= ActionDispatch::Routing::RouteSet.new
     end
 
     def self.call(env)
@@ -27,12 +27,28 @@ class TestRoutingMount < ActionDispatch::IntegrationTest
     scope "/its_a" do
       mount SprocketsApp, :at => "/sprocket"
     end
+
+    resources :users do
+      mount FakeEngine, :at => "/fakeengine", :as => :fake_mounted_at_resource
+    end
   end
 
   def app
     Router
   end
 
+  def test_app_name_is_properly_generated_when_engine_is_mounted_in_resources
+    assert Router.mounted_helpers.method_defined?(:user_fake_mounted_at_resource),
+          "A mounted helper should be defined with a parent's prefix"
+    assert Router.named_routes.routes[:user_fake_mounted_at_resource],
+          "A named route should be defined with a parent's prefix"
+  end
+
+  def test_trailing_slash_is_not_removed_from_path_info
+    get "/sprockets/omg/"
+    assert_equal "/sprockets -- /omg/", response.body
+  end
+
   def test_mounting_sets_script_name
     get "/sprockets/omg"
     assert_equal "/sprockets -- /omg", response.body
diff --git a/actionpack/test/dispatch/prefix_generation_test.rb b/actionpack/test/dispatch/prefix_generation_test.rb
index 113608ecf4..08501d19c0 100644
--- a/actionpack/test/dispatch/prefix_generation_test.rb
+++ b/actionpack/test/dispatch/prefix_generation_test.rb
@@ -31,6 +31,20 @@ module TestGenerationPrefix
             get "/polymorphic_path_for_engine", :to => "inside_engine_generating#polymorphic_path_for_engine"
             get "/conflicting_url", :to => "inside_engine_generating#conflicting"
             get "/foo", :to => "never#invoked", :as => :named_helper_that_should_be_invoked_only_in_respond_to_test
+
+            get "/relative_path_root",       :to => redirect("")
+            get "/relative_path_redirect",   :to => redirect("foo")
+            get "/relative_option_root",     :to => redirect(:path => "")
+            get "/relative_option_redirect", :to => redirect(:path => "foo")
+            get "/relative_custom_root",     :to => redirect { |params, request| "" }
+            get "/relative_custom_redirect", :to => redirect { |params, request| "foo" }
+
+            get "/absolute_path_root",       :to => redirect("/")
+            get "/absolute_path_redirect",   :to => redirect("/foo")
+            get "/absolute_option_root",     :to => redirect(:path => "/")
+            get "/absolute_option_redirect", :to => redirect(:path => "/foo")
+            get "/absolute_custom_root",     :to => redirect { |params, request| "/" }
+            get "/absolute_custom_redirect", :to => redirect { |params, request| "/foo" }
           end
 
           routes
@@ -182,6 +196,66 @@ module TestGenerationPrefix
       assert_equal "engine", last_response.body
     end
 
+    test "[ENGINE] relative path root uses SCRIPT_NAME from request" do
+      get "/awesome/blog/relative_path_root"
+      verify_redirect "http://example.org/awesome/blog"
+    end
+
+    test "[ENGINE] relative path redirect uses SCRIPT_NAME from request" do
+      get "/awesome/blog/relative_path_redirect"
+      verify_redirect "http://example.org/awesome/blog/foo"
+    end
+
+    test "[ENGINE] relative option root uses SCRIPT_NAME from request" do
+      get "/awesome/blog/relative_option_root"
+      verify_redirect "http://example.org/awesome/blog"
+    end
+
+    test "[ENGINE] relative option redirect uses SCRIPT_NAME from request" do
+      get "/awesome/blog/relative_option_redirect"
+      verify_redirect "http://example.org/awesome/blog/foo"
+    end
+
+    test "[ENGINE] relative custom root uses SCRIPT_NAME from request" do
+      get "/awesome/blog/relative_custom_root"
+      verify_redirect "http://example.org/awesome/blog"
+    end
+
+    test "[ENGINE] relative custom redirect uses SCRIPT_NAME from request" do
+      get "/awesome/blog/relative_custom_redirect"
+      verify_redirect "http://example.org/awesome/blog/foo"
+    end
+
+    test "[ENGINE] absolute path root doesn't use SCRIPT_NAME from request" do
+      get "/awesome/blog/absolute_path_root"
+      verify_redirect "http://example.org/"
+    end
+
+    test "[ENGINE] absolute path redirect doesn't use SCRIPT_NAME from request" do
+      get "/awesome/blog/absolute_path_redirect"
+      verify_redirect "http://example.org/foo"
+    end
+
+    test "[ENGINE] absolute option root doesn't use SCRIPT_NAME from request" do
+      get "/awesome/blog/absolute_option_root"
+      verify_redirect "http://example.org/"
+    end
+
+    test "[ENGINE] absolute option redirect doesn't use SCRIPT_NAME from request" do
+      get "/awesome/blog/absolute_option_redirect"
+      verify_redirect "http://example.org/foo"
+    end
+
+    test "[ENGINE] absolute custom root doesn't use SCRIPT_NAME from request" do
+      get "/awesome/blog/absolute_custom_root"
+      verify_redirect "http://example.org/"
+    end
+
+    test "[ENGINE] absolute custom redirect doesn't use SCRIPT_NAME from request" do
+      get "/awesome/blog/absolute_custom_redirect"
+      verify_redirect "http://example.org/foo"
+    end
+
     # Inside Application
     test "[APP] generating engine's route includes prefix" do
       get "/generate"
@@ -270,6 +344,17 @@ module TestGenerationPrefix
       path = engine_object.polymorphic_url(Post.new, :host => "www.example.com")
       assert_equal "http://www.example.com/awesome/blog/posts/1", path
     end
+    
+    private
+      def verify_redirect(url, status = 301)
+        assert_equal status, last_response.status
+        assert_equal url, last_response.headers["Location"]
+        assert_equal expected_redirect_body(url), last_response.body
+      end
+      
+      def expected_redirect_body(url)
+        %(<html><body>You are being <a href="#{url}">redirected</a>.</body></html>)
+      end
   end
 
   class EngineMountedAtRoot < ActionDispatch::IntegrationTest
@@ -281,6 +366,20 @@ module TestGenerationPrefix
           routes = ActionDispatch::Routing::RouteSet.new
           routes.draw do
             get "/posts/:id", :to => "posts#show", :as => :post
+
+            get "/relative_path_root",       :to => redirect("")
+            get "/relative_path_redirect",   :to => redirect("foo")
+            get "/relative_option_root",     :to => redirect(:path => "")
+            get "/relative_option_redirect", :to => redirect(:path => "foo")
+            get "/relative_custom_root",     :to => redirect { |params, request| "" }
+            get "/relative_custom_redirect", :to => redirect { |params, request| "foo" }
+
+            get "/absolute_path_root",       :to => redirect("/")
+            get "/absolute_path_redirect",   :to => redirect("/foo")
+            get "/absolute_option_root",     :to => redirect(:path => "/")
+            get "/absolute_option_redirect", :to => redirect(:path => "/foo")
+            get "/absolute_custom_root",     :to => redirect { |params, request| "/" }
+            get "/absolute_custom_redirect", :to => redirect { |params, request| "/foo" }
           end
 
           routes
@@ -331,5 +430,76 @@ module TestGenerationPrefix
       get "/posts/1"
       assert_equal "/posts/1", last_response.body
     end
+
+    test "[ENGINE] relative path root uses SCRIPT_NAME from request" do
+      get "/relative_path_root"
+      verify_redirect "http://example.org/"
+    end
+
+    test "[ENGINE] relative path redirect uses SCRIPT_NAME from request" do
+      get "/relative_path_redirect"
+      verify_redirect "http://example.org/foo"
+    end
+
+    test "[ENGINE] relative option root uses SCRIPT_NAME from request" do
+      get "/relative_option_root"
+      verify_redirect "http://example.org/"
+    end
+
+    test "[ENGINE] relative option redirect uses SCRIPT_NAME from request" do
+      get "/relative_option_redirect"
+      verify_redirect "http://example.org/foo"
+    end
+
+    test "[ENGINE] relative custom root uses SCRIPT_NAME from request" do
+      get "/relative_custom_root"
+      verify_redirect "http://example.org/"
+    end
+
+    test "[ENGINE] relative custom redirect uses SCRIPT_NAME from request" do
+      get "/relative_custom_redirect"
+      verify_redirect "http://example.org/foo"
+    end
+
+    test "[ENGINE] absolute path root doesn't use SCRIPT_NAME from request" do
+      get "/absolute_path_root"
+      verify_redirect "http://example.org/"
+    end
+
+    test "[ENGINE] absolute path redirect doesn't use SCRIPT_NAME from request" do
+      get "/absolute_path_redirect"
+      verify_redirect "http://example.org/foo"
+    end
+
+    test "[ENGINE] absolute option root doesn't use SCRIPT_NAME from request" do
+      get "/absolute_option_root"
+      verify_redirect "http://example.org/"
+    end
+
+    test "[ENGINE] absolute option redirect doesn't use SCRIPT_NAME from request" do
+      get "/absolute_option_redirect"
+      verify_redirect "http://example.org/foo"
+    end
+
+    test "[ENGINE] absolute custom root doesn't use SCRIPT_NAME from request" do
+      get "/absolute_custom_root"
+      verify_redirect "http://example.org/"
+    end
+
+    test "[ENGINE] absolute custom redirect doesn't use SCRIPT_NAME from request" do
+      get "/absolute_custom_redirect"
+      verify_redirect "http://example.org/foo"
+    end
+    
+    private
+      def verify_redirect(url, status = 301)
+        assert_equal status, last_response.status
+        assert_equal url, last_response.headers["Location"]
+        assert_equal expected_redirect_body(url), last_response.body
+      end
+      
+      def expected_redirect_body(url)
+        %(<html><body>You are being <a href="#{url}">redirected</a>.</body></html>)
+      end
   end
 end
diff --git a/actionpack/test/dispatch/rack_test.rb b/actionpack/test/dispatch/rack_test.rb
index 6d239d0a0c..42067854ee 100644
--- a/actionpack/test/dispatch/rack_test.rb
+++ b/actionpack/test/dispatch/rack_test.rb
@@ -174,22 +174,6 @@ class RackRequestParamsParsingTest < BaseRackTest
   end
 end
 
-class RackRequestContentTypeTest < BaseRackTest
-  test "html content type verification" do
-    assert_deprecated do
-      @request.env['CONTENT_TYPE'] = Mime::HTML.to_s
-      assert @request.content_mime_type.verify_request?
-    end
-  end
-
-  test "xml content type verification" do
-    assert_deprecated do
-      @request.env['CONTENT_TYPE'] = Mime::XML.to_s
-      assert !@request.content_mime_type.verify_request?
-    end
-  end
-end
-
 class RackRequestNeedsRewoundTest < BaseRackTest
   test "body should be rewound" do
     data = 'foo'
diff --git a/actionpack/test/dispatch/request/json_params_parsing_test.rb b/actionpack/test/dispatch/request/json_params_parsing_test.rb
index b62ed6a8b2..dba9ab688f 100644
--- a/actionpack/test/dispatch/request/json_params_parsing_test.rb
+++ b/actionpack/test/dispatch/request/json_params_parsing_test.rb
@@ -70,6 +70,13 @@ class JsonParamsParsingTest < ActionDispatch::IntegrationTest
     end
   end
 
+  test 'raw_post is not empty for JSON request' do
+    with_test_routing do
+      post '/parse', '{"posts": [{"title": "Post Title"}]}', 'CONTENT_TYPE' => 'application/json'
+      assert_equal '{"posts": [{"title": "Post Title"}]}', request.raw_post
+    end
+  end
+
   private
     def assert_parses(expected, actual, headers = {})
       with_test_routing do
diff --git a/actionpack/test/dispatch/request/multipart_params_parsing_test.rb b/actionpack/test/dispatch/request/multipart_params_parsing_test.rb
index 3c30a705e9..2a2f92b5b3 100644
--- a/actionpack/test/dispatch/request/multipart_params_parsing_test.rb
+++ b/actionpack/test/dispatch/request/multipart_params_parsing_test.rb
@@ -108,8 +108,7 @@ class MultipartParamsParsingTest < ActionDispatch::IntegrationTest
 
     # Rack doesn't handle multipart/mixed for us.
     files = params['files']
-    files.force_encoding('ASCII-8BIT')
-    assert_equal 19756, files.size
+    assert_equal 19756, files.bytesize
   end
 
   test "does not create tempfile if no file has been selected" do
diff --git a/actionpack/test/dispatch/request/query_string_parsing_test.rb b/actionpack/test/dispatch/request/query_string_parsing_test.rb
index f072a9f717..d82493140f 100644
--- a/actionpack/test/dispatch/request/query_string_parsing_test.rb
+++ b/actionpack/test/dispatch/request/query_string_parsing_test.rb
@@ -11,6 +11,17 @@ class QueryStringParsingTest < ActionDispatch::IntegrationTest
       head :ok
     end
   end
+  class EarlyParse
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      # Trigger a Rack parse so that env caches the query params
+      Rack::Request.new(env).params
+      @app.call(env)
+    end
+  end
 
   def teardown
     TestController.last_query_parameters = nil
@@ -93,6 +104,21 @@ class QueryStringParsingTest < ActionDispatch::IntegrationTest
     assert_parses({"action" => ['1']}, "action[]=1&action[]")
   end
 
+  test "perform_deep_munge" do
+    ActionDispatch::Request::Utils.perform_deep_munge = false
+    begin
+      assert_parses({"action" => nil}, "action")
+      assert_parses({"action" => {"foo" => nil}}, "action[foo]")
+      assert_parses({"action" => {"foo" => {"bar" => nil}}}, "action[foo][bar]")
+      assert_parses({"action" => {"foo" => {"bar" => [nil]}}}, "action[foo][bar][]")
+      assert_parses({"action" => {"foo" => [nil]}}, "action[foo][]")
+      assert_parses({"action" => {"foo" => [{"bar" => nil}]}}, "action[foo][][bar]")
+      assert_parses({"action" => ['1',nil]}, "action[]=1&action[]")
+    ensure
+      ActionDispatch::Request::Utils.perform_deep_munge = true
+    end
+  end
+
   test "query string with empty key" do
     assert_parses(
       { "action" => "create_customer", "full_name" => "David Heinemeier Hansson" },
@@ -131,6 +157,10 @@ class QueryStringParsingTest < ActionDispatch::IntegrationTest
         set.draw do
           get ':action', :to => ::QueryStringParsingTest::TestController
         end
+        @app = self.class.build_app(set) do |middleware|
+          middleware.use(EarlyParse)
+        end
+
 
         get "/parse", actual
         assert_response :ok
diff --git a/actionpack/test/dispatch/request/session_test.rb b/actionpack/test/dispatch/request/session_test.rb
index 1517f96fdc..df55fcc8bc 100644
--- a/actionpack/test/dispatch/request/session_test.rb
+++ b/actionpack/test/dispatch/request/session_test.rb
@@ -61,6 +61,22 @@ module ActionDispatch
         assert_equal([], s.values)
       end
 
+      def test_fetch
+        session = Session.create(store, {}, {})
+
+        session['one'] = '1'
+        assert_equal '1', session.fetch(:one)
+
+        assert_equal '2', session.fetch(:two, '2')
+        assert_nil session.fetch(:two, nil)
+
+        assert_equal 'three', session.fetch(:three) {|el| el.to_s }
+
+        assert_raise KeyError do
+          session.fetch(:three)
+        end
+      end
+
       private
       def store
         Class.new {
diff --git a/actionpack/test/dispatch/request/url_encoded_params_parsing_test.rb b/actionpack/test/dispatch/request/url_encoded_params_parsing_test.rb
index 9169658c22..9a77454f30 100644
--- a/actionpack/test/dispatch/request/url_encoded_params_parsing_test.rb
+++ b/actionpack/test/dispatch/request/url_encoded_params_parsing_test.rb
@@ -17,10 +17,9 @@ class UrlEncodedParamsParsingTest < ActionDispatch::IntegrationTest
   end
 
   test "parses unbalanced query string with array" do
-    assert_parses(
-       {'location' => ["1", "2"], 'age_group' => ["2"]},
-      "location[]=1&location[]=2&age_group[]=2"
-    )
+    query    = "location[]=1&location[]=2&age_group[]=2"
+    expected = { 'location' => ["1", "2"], 'age_group' => ["2"] }
+    assert_parses expected, query
   end
 
   test "parses nested hash" do
@@ -30,9 +29,17 @@ class UrlEncodedParamsParsingTest < ActionDispatch::IntegrationTest
       "note[viewers][viewer][][type]=Group",
       "note[viewers][viewer][][id]=2"
     ].join("&")
-
-    expected = { "note" => { "viewers"=>{"viewer"=>[{ "id"=>"1", "type"=>"User"}, {"type"=>"Group", "id"=>"2"} ]} } }
-    assert_parses(expected, query)
+    expected = {
+      "note" => {
+        "viewers" => {
+          "viewer" => [
+            { "id" => "1", "type" => "User" },
+            { "type" => "Group", "id" => "2" }
+          ]
+        }
+      }
+    }
+    assert_parses expected, query
   end
 
   test "parses more complex nesting" do
@@ -48,7 +55,6 @@ class UrlEncodedParamsParsingTest < ActionDispatch::IntegrationTest
       "products[second]=Pc",
       "=Save"
     ].join("&")
-
     expected =  {
       "customers" => {
         "boston" => {
@@ -70,13 +76,12 @@ class UrlEncodedParamsParsingTest < ActionDispatch::IntegrationTest
         "second" => "Pc"
       }
     }
-
     assert_parses expected, query
   end
 
   test "parses params with array" do
-    query = "selected[]=1&selected[]=2&selected[]=3"
-    expected = { "selected" => [ "1", "2", "3" ] }
+    query    = "selected[]=1&selected[]=2&selected[]=3"
+    expected = { "selected" => ["1", "2", "3"] }
     assert_parses expected, query
   end
 
@@ -88,13 +93,13 @@ class UrlEncodedParamsParsingTest < ActionDispatch::IntegrationTest
 
   test "parses params with array prefix and hashes" do
     query    = "a[][b][c]=d"
-    expected = {"a" => [{"b" => {"c" => "d"}}]}
+    expected = { "a" => [{ "b" => { "c" => "d" } }] }
     assert_parses expected, query
   end
 
   test "parses params with complex nesting" do
     query    = "a[][b][c][][d][]=e"
-    expected = {"a" => [{"b" => {"c" => [{"d" => ["e"]}]}}]}
+    expected = { "a" => [{ "b" => { "c" => [{ "d" => ["e"] }] } }] }
     assert_parses expected, query
   end
 
@@ -104,7 +109,6 @@ class UrlEncodedParamsParsingTest < ActionDispatch::IntegrationTest
       "something_else=blah",
       "logo=#{File.expand_path(__FILE__)}"
     ].join("&")
-
     expected = {
       "customers" => {
         "boston" => {
@@ -116,22 +120,20 @@ class UrlEncodedParamsParsingTest < ActionDispatch::IntegrationTest
       "something_else" => "blah",
       "logo" => File.expand_path(__FILE__),
     }
-
     assert_parses expected, query
   end
 
   test "parses params with Safari 2 trailing null character" do
-    query = "selected[]=1&selected[]=2&selected[]=3\0"
-    expected = { "selected" => [ "1", "2", "3" ] }
+    query    = "selected[]=1&selected[]=2&selected[]=3\0"
+    expected = { "selected" => ["1", "2", "3"] }
     assert_parses expected, query
   end
 
   test "ambiguous params returns a bad request" do
     with_routing do |set|
       set.draw do
-        post ':action', :to => ::UrlEncodedParamsParsingTest::TestController
+        post ':action', to: ::UrlEncodedParamsParsingTest::TestController
       end
-
       post "/parse", "foo[]=bar&foo[4]=bar"
       assert_response :bad_request
     end
@@ -141,7 +143,7 @@ class UrlEncodedParamsParsingTest < ActionDispatch::IntegrationTest
     def with_test_routing
       with_routing do |set|
         set.draw do
-          post ':action', :to => ::UrlEncodedParamsParsingTest::TestController
+          post ':action', to: ::UrlEncodedParamsParsingTest::TestController
         end
         yield
       end
@@ -151,8 +153,8 @@ class UrlEncodedParamsParsingTest < ActionDispatch::IntegrationTest
       with_test_routing do
         post "/parse", actual
         assert_response :ok
-        assert_equal(expected, TestController.last_request_parameters)
-        assert_utf8(TestController.last_request_parameters)
+        assert_equal expected, TestController.last_request_parameters
+        assert_utf8 TestController.last_request_parameters
       end
     end
 
@@ -167,11 +169,11 @@ class UrlEncodedParamsParsingTest < ActionDispatch::IntegrationTest
       object.each_value do |v|
         case v
         when Hash
-          assert_utf8(v)
+          assert_utf8 v
         when Array
-          v.each {|el| assert_utf8(el) }
+          v.each { |el| assert_utf8 el }
         else
-          assert_utf8(v)
+          assert_utf8 v
         end
       end
     end
diff --git a/actionpack/test/dispatch/request_test.rb b/actionpack/test/dispatch/request_test.rb
index f6de9748ca..f79fe47897 100644
--- a/actionpack/test/dispatch/request_test.rb
+++ b/actionpack/test/dispatch/request_test.rb
@@ -93,6 +93,14 @@ class RequestTest < ActiveSupport::TestCase
     assert_equal '1.1.1.1', request.remote_ip
   end
 
+  test "remote ip spoof protection ignores private addresses" do
+    request = stub_request 'HTTP_X_FORWARDED_FOR' => '172.17.19.51',
+                           'HTTP_CLIENT_IP'       => '172.17.19.51',
+                           'REMOTE_ADDR'          => '1.1.1.1',
+                           'HTTP_X_BLUECOAT_VIA'  => 'de462e07a2db325e'
+    assert_equal '1.1.1.1', request.remote_ip
+  end
+
   test "remote ip v6" do
     request = stub_request 'REMOTE_ADDR' => '2001:0db8:85a3:0000:0000:8a2e:0370:7334'
     assert_equal '2001:0db8:85a3:0000:0000:8a2e:0370:7334', request.remote_ip
@@ -598,7 +606,7 @@ class RequestTest < ActiveSupport::TestCase
                            'HTTP_X_REQUESTED_WITH' => "XMLHttpRequest"
     request.expects(:parameters).at_least_once.returns({})
     assert_equal [Mime::JS], request.formats
-    
+
     request = stub_request 'CONTENT_TYPE' => 'application/xml; charset=UTF-8',
                            'HTTP_X_REQUESTED_WITH' => "XMLHttpRequest"
     request.expects(:parameters).at_least_once.returns({})
@@ -616,10 +624,10 @@ class RequestTest < ActiveSupport::TestCase
   test "format is not nil with unknown format" do
     request = stub_request
     request.expects(:parameters).at_least_once.returns({ format: :hello })
-    assert_equal request.format.nil?, true
-    assert_equal request.format.html?, false
-    assert_equal request.format.xml?, false
-    assert_equal request.format.json?, false
+    assert request.format.nil?
+    assert_not request.format.html?
+    assert_not request.format.xml?
+    assert_not request.format.json?
   end
 
   test "formats with xhr request" do
@@ -836,6 +844,19 @@ class RequestTest < ActiveSupport::TestCase
     end
   end
 
+  test "setting variant" do
+    request = stub_request
+    request.variant = :mobile
+    assert_equal :mobile, request.variant
+  end
+
+  test "setting variant with non symbol value" do
+    request = stub_request
+    assert_raise ArgumentError do
+      request.variant = "mobile"
+    end
+  end
+
 protected
 
   def stub_request(env = {})
diff --git a/actionpack/test/dispatch/response_test.rb b/actionpack/test/dispatch/response_test.rb
index 74f5253c11..4501ea095c 100644
--- a/actionpack/test/dispatch/response_test.rb
+++ b/actionpack/test/dispatch/response_test.rb
@@ -182,8 +182,7 @@ class ResponseTest < ActiveSupport::TestCase
       ActionDispatch::Response.default_headers = {
         'X-Frame-Options' => 'DENY',
         'X-Content-Type-Options' => 'nosniff',
-        'X-XSS-Protection' => '1;',
-        'X-UA-Compatible' => 'chrome=1'
+        'X-XSS-Protection' => '1;'
       }
       resp = ActionDispatch::Response.new.tap { |response|
         response.body = 'Hello'
@@ -193,7 +192,6 @@ class ResponseTest < ActiveSupport::TestCase
       assert_equal('DENY', resp.headers['X-Frame-Options'])
       assert_equal('nosniff', resp.headers['X-Content-Type-Options'])
       assert_equal('1;', resp.headers['X-XSS-Protection'])
-      assert_equal('chrome=1', resp.headers['X-UA-Compatible'])
     ensure
       ActionDispatch::Response.default_headers = nil
     end
@@ -214,6 +212,11 @@ class ResponseTest < ActiveSupport::TestCase
       ActionDispatch::Response.default_headers = nil
     end
   end
+
+  test "respond_to? accepts include_private" do
+    assert_not @response.respond_to?(:method_missing)
+    assert @response.respond_to?(:method_missing, true)
+  end
 end
 
 class ResponseIntegrationTest < ActionDispatch::IntegrationTest
diff --git a/actionpack/test/dispatch/routing/inspector_test.rb b/actionpack/test/dispatch/routing/inspector_test.rb
index 234ae5764f..18a52f13a7 100644
--- a/actionpack/test/dispatch/routing/inspector_test.rb
+++ b/actionpack/test/dispatch/routing/inspector_test.rb
@@ -46,11 +46,11 @@ module ActionDispatch
 
         assert_equal [
           "       Prefix Verb URI Pattern              Controller#Action",
-          "custom_assets GET /custom/assets(.:format) custom_assets#show",
-          "         blog     /blog                    Blog::Engine",
+          "custom_assets GET  /custom/assets(.:format) custom_assets#show",
+          "         blog      /blog                    Blog::Engine",
           "",
           "Routes for Blog::Engine:",
-          "cart GET /cart(.:format) cart#show"
+          "  cart GET  /cart(.:format) cart#show"
         ], output
       end
 
@@ -61,7 +61,7 @@ module ActionDispatch
 
         assert_equal [
           "Prefix Verb URI Pattern     Controller#Action",
-          "cart GET /cart(.:format) cart#show"
+          "  cart GET  /cart(.:format) cart#show"
         ], output
       end
 
@@ -72,7 +72,7 @@ module ActionDispatch
 
         assert_equal [
           "       Prefix Verb URI Pattern              Controller#Action",
-          "custom_assets GET /custom/assets(.:format) custom_assets#show"
+          "custom_assets GET  /custom/assets(.:format) custom_assets#show"
         ], output
       end
 
@@ -101,7 +101,7 @@ module ActionDispatch
 
         assert_equal [
           "Prefix Verb URI Pattern Controller#Action",
-          "root GET / pages#main"
+          "  root GET  /           pages#main"
         ], output
       end
 
@@ -112,7 +112,7 @@ module ActionDispatch
 
         assert_equal [
           "Prefix Verb URI Pattern            Controller#Action",
-          " GET /api/:action(.:format) api#:action"
+          "       GET  /api/:action(.:format) api#:action"
         ], output
       end
 
@@ -123,7 +123,7 @@ module ActionDispatch
 
         assert_equal [
           "Prefix Verb URI Pattern                    Controller#Action",
-          " GET /:controller/:action(.:format) :controller#:action"
+          "       GET  /:controller/:action(.:format) :controller#:action"
         ], output
       end
 
@@ -134,7 +134,7 @@ module ActionDispatch
 
         assert_equal [
           "Prefix Verb URI Pattern                            Controller#Action",
-          " GET /:controller(/:action(/:id))(.:format) :controller#:action {:id=>/\\d+/}"
+          "       GET  /:controller(/:action(/:id))(.:format) :controller#:action {:id=>/\\d+/}"
         ], output
       end
 
@@ -145,7 +145,7 @@ module ActionDispatch
 
         assert_equal [
           "Prefix Verb URI Pattern           Controller#Action",
-          %Q[ GET /photos/:id(.:format) photos#show {:format=>"jpg"}]
+          %Q[       GET  /photos/:id(.:format) photos#show {:format=>"jpg"}]
         ], output
       end
 
@@ -156,7 +156,7 @@ module ActionDispatch
 
         assert_equal [
           "Prefix Verb URI Pattern           Controller#Action",
-          " GET /photos/:id(.:format) photos#show {:id=>/[A-Z]\\d{5}/}"
+          "       GET  /photos/:id(.:format) photos#show {:id=>/[A-Z]\\d{5}/}"
         ], output
       end
 
@@ -172,7 +172,7 @@ module ActionDispatch
 
         assert_equal [
           "Prefix Verb URI Pattern        Controller#Action",
-          " GET /foo/:id(.:format) #{RackApp.name} {:id=>/[A-Z]\\d{5}/}"
+          "       GET  /foo/:id(.:format) #{RackApp.name} {:id=>/[A-Z]\\d{5}/}"
         ], output
       end
 
@@ -191,7 +191,7 @@ module ActionDispatch
 
         assert_equal [
           "Prefix Verb URI Pattern Controller#Action",
-          "  /foo #{RackApp.name} {:constraint=>( my custom constraint )}"
+          "            /foo        #{RackApp.name} {:constraint=>( my custom constraint )}"
         ], output
       end
 
@@ -203,6 +203,18 @@ module ActionDispatch
         assert_no_match(/\/sprockets/, output.first)
       end
 
+      def test_rake_routes_shows_route_defined_in_under_assets_prefix
+        output = draw do
+          scope '/sprockets' do
+            get '/foo' => 'foo#bar'
+          end
+        end
+        assert_equal [
+          "Prefix Verb URI Pattern              Controller#Action",
+          "   foo GET  /sprockets/foo(.:format) foo#bar"
+        ], output
+      end
+
       def test_redirect
         output = draw do
           get "/foo"    => redirect("/foo/bar"), :constraints => { :subdomain => "admin" }
@@ -212,9 +224,9 @@ module ActionDispatch
 
         assert_equal [
           "Prefix Verb URI Pattern       Controller#Action",
-          "   foo GET /foo(.:format)    redirect(301, /foo/bar) {:subdomain=>\"admin\"}",
-          "   bar GET /bar(.:format)    redirect(307, path: /foo/bar)",
-          "foobar GET /foobar(.:format) redirect(301)"
+          "   foo GET  /foo(.:format)    redirect(301, /foo/bar) {:subdomain=>\"admin\"}",
+          "   bar GET  /bar(.:format)    redirect(307, path: /foo/bar)",
+          "foobar GET  /foobar(.:format) redirect(301)"
         ], output
       end
 
@@ -234,6 +246,15 @@ module ActionDispatch
                       "          PUT    /posts/:id(.:format)      posts#update",
                       "          DELETE /posts/:id(.:format)      posts#destroy"], output
       end
+
+      def test_regression_route_with_controller_regexp
+        output = draw do
+          get ':controller(/:action)', controller: /api\/[^\/]+/, format: false
+        end
+
+        assert_equal ["Prefix Verb URI Pattern            Controller#Action",
+                      "       GET  /:controller(/:action) (?-mix:api\\/[^\\/]+)#:action"], output
+      end
     end
   end
 end
diff --git a/actionpack/test/dispatch/routing_test.rb b/actionpack/test/dispatch/routing_test.rb
index 16ba746b9c..5a532dc38f 100644
--- a/actionpack/test/dispatch/routing_test.rb
+++ b/actionpack/test/dispatch/routing_test.rb
@@ -1102,6 +1102,19 @@ class TestRoutingMapper < ActionDispatch::IntegrationTest
     assert_equal 'projects#index', @response.body
   end
 
+  def test_scoped_root_as_name
+    draw do
+      scope '(:locale)', :locale => /en|pl/ do
+        root :to => 'projects#index', :as => 'projects'
+      end
+    end
+
+    assert_equal '/en', projects_path(:locale => 'en')
+    assert_equal '/', projects_path
+    get '/en'
+    assert_equal 'projects#index', @response.body
+  end
+
   def test_scope_with_format_option
     draw do
       get "direct/index", as: :no_format_direct, format: false
@@ -1253,6 +1266,19 @@ class TestRoutingMapper < ActionDispatch::IntegrationTest
     assert_equal 'api/v3/products#list', @response.body
   end
 
+  def test_controller_option_with_nesting_and_leading_slash
+    draw do
+      scope '/job', controller: 'job' do
+        scope ':id', action: 'manage_applicant' do
+          get "/active"
+        end
+      end
+    end
+
+    get '/job/5/active'
+    assert_equal 'job#manage_applicant', @response.body
+  end
+
   def test_dynamically_generated_helpers_on_collection_do_not_clobber_resources_url_helper
     draw do
       resources :replies do
@@ -2838,6 +2864,36 @@ class TestRoutingMapper < ActionDispatch::IntegrationTest
     assert !@request.params[:action].frozen?
   end
 
+  def test_multiple_positional_args_with_the_same_name
+    draw do
+      get '/downloads/:id/:id.tar' => 'downloads#show', as: :download, format: false
+    end
+
+    expected_params = {
+      controller: 'downloads',
+      action:     'show',
+      id:         '1'
+    }
+
+    get '/downloads/1/1.tar'
+    assert_equal 'downloads#show', @response.body
+    assert_equal expected_params, @request.symbolized_path_parameters
+    assert_equal '/downloads/1/1.tar', download_path('1')
+    assert_equal '/downloads/1/1.tar', download_path('1', '1')
+  end
+
+  def test_absolute_controller_namespace
+    draw do
+      namespace :foo do
+        get '/', to: '/bar#index', as: 'root'
+      end
+    end
+
+    get '/foo'
+    assert_equal 'bar#index', @response.body
+    assert_equal '/foo', foo_root_path
+  end
+
 private
 
   def draw(&block)
@@ -3209,7 +3265,9 @@ class TestRedirectInterpolation < ActionDispatch::IntegrationTest
 
       get "/foo/:id" => redirect("/foo/bar/%{id}")
       get "/bar/:id" => redirect(:path => "/foo/bar/%{id}")
+      get "/baz/:id" => redirect("/baz?id=%{id}&foo=?&bar=1#id-%{id}")
       get "/foo/bar/:id" => ok
+      get "/baz" => ok
     end
   end
 
@@ -3225,6 +3283,14 @@ class TestRedirectInterpolation < ActionDispatch::IntegrationTest
     verify_redirect "http://www.example.com/foo/bar/1%3E"
   end
 
+  test "path redirect escapes interpolated parameters correctly" do
+    get "/foo/1%201"
+    verify_redirect "http://www.example.com/foo/bar/1%201"
+
+    get "/baz/1%201"
+    verify_redirect "http://www.example.com/baz?id=1+1&foo=?&bar=1#id-1%201"
+  end
+
 private
   def verify_redirect(url, status=301)
     assert_equal status, @response.status
@@ -3291,6 +3357,8 @@ class TestOptimizedNamedRoutes < ActionDispatch::IntegrationTest
       ok = lambda { |env| [200, { 'Content-Type' => 'text/plain' }, []] }
       get '/foo' => ok, as: :foo
       get '/post(/:action(/:id))' => ok, as: :posts
+      get '/:foo/:foo_type/bars/:id' => ok, as: :bar
+      get '/projects/:id.:format' => ok, as: :project
     end
   end
 
@@ -3313,6 +3381,16 @@ class TestOptimizedNamedRoutes < ActionDispatch::IntegrationTest
     assert_equal '/post', Routes.url_helpers.posts_path
     assert_equal '/post', posts_path
   end
+
+  test 'segments with same prefix are replaced correctly' do
+    assert_equal '/foo/baz/bars/1', Routes.url_helpers.bar_path('foo', 'baz', '1')
+    assert_equal '/foo/baz/bars/1', bar_path('foo', 'baz', '1')
+  end
+
+  test 'segments separated with a period are replaced correctly' do
+    assert_equal '/projects/1.json', Routes.url_helpers.project_path(1, :json)
+    assert_equal '/projects/1.json', project_path(1, :json)
+  end
 end
 
 class TestNamedRouteUrlHelpers < ActionDispatch::IntegrationTest
@@ -3607,3 +3685,81 @@ class TestRouteDefaults < ActionDispatch::IntegrationTest
     assert_equal '/projects/1', url_for(controller: 'projects', action: 'show', id: 1, only_path: true)
   end
 end
+
+class TestRackAppRouteGeneration < ActionDispatch::IntegrationTest
+  stub_controllers do |routes|
+    Routes = routes
+    Routes.draw do
+      rack_app = lambda { |env| [200, { 'Content-Type' => 'text/plain' }, []] }
+      mount rack_app, at: '/account', as: 'account'
+      mount rack_app, at: '/:locale/account', as: 'localized_account'
+    end
+  end
+
+  def app
+    Routes
+  end
+
+  include Routes.url_helpers
+
+  def test_mounted_application_doesnt_match_unnamed_route
+    assert_raise(ActionController::UrlGenerationError) do
+      assert_equal '/account?controller=products', url_for(controller: 'products', action: 'index', only_path: true)
+    end
+
+    assert_raise(ActionController::UrlGenerationError) do
+      assert_equal '/de/account?controller=products', url_for(controller: 'products', action: 'index', :locale => 'de', only_path: true)
+    end
+  end
+end
+
+class TestRedirectRouteGeneration < ActionDispatch::IntegrationTest
+  stub_controllers do |routes|
+    Routes = routes
+    Routes.draw do
+      get '/account', to: redirect('/myaccount'), as: 'account'
+      get '/:locale/account', to: redirect('/%{locale}/myaccount'), as: 'localized_account'
+    end
+  end
+
+  def app
+    Routes
+  end
+
+  include Routes.url_helpers
+
+  def test_redirect_doesnt_match_unnamed_route
+    assert_raise(ActionController::UrlGenerationError) do
+      assert_equal '/account?controller=products', url_for(controller: 'products', action: 'index', only_path: true)
+    end
+
+    assert_raise(ActionController::UrlGenerationError) do
+      assert_equal '/de/account?controller=products', url_for(controller: 'products', action: 'index', :locale => 'de', only_path: true)
+    end
+  end
+end
+
+class TestUrlGenerationErrors < ActionDispatch::IntegrationTest
+  Routes = ActionDispatch::Routing::RouteSet.new.tap do |app|
+    app.draw do
+      get "/products/:id" => 'products#show', :as => :product
+    end
+  end
+
+  def app; Routes end
+
+  include Routes.url_helpers
+
+  test "url helpers raise a helpful error message whem generation fails" do
+    url, missing = { action: 'show', controller: 'products', id: nil }, [:id]
+    message = "No route matches #{url.inspect} missing required keys: #{missing.inspect}"
+
+    # Optimized url helper
+    error = assert_raises(ActionController::UrlGenerationError){ product_path(nil) }
+    assert_equal message, error.message
+
+    # Non-optimized url helper
+    error = assert_raises(ActionController::UrlGenerationError, message){ product_path(id: nil) }
+    assert_equal message, error.message
+  end
+end
diff --git a/actionpack/test/dispatch/ssl_test.rb b/actionpack/test/dispatch/ssl_test.rb
index a9bea7ea73..94969f795a 100644
--- a/actionpack/test/dispatch/ssl_test.rb
+++ b/actionpack/test/dispatch/ssl_test.rb
@@ -37,6 +37,11 @@ class SSLTest < ActionDispatch::IntegrationTest
       response.headers['Strict-Transport-Security']
   end
 
+  def test_no_hsts_with_insecure_connection
+    get "http://example.org/"
+    assert_not response.headers['Strict-Transport-Security']
+  end
+
   def test_hsts_header
     self.app = ActionDispatch::SSL.new(default_app, :hsts => true)
     get "https://example.org/"
@@ -119,6 +124,49 @@ class SSLTest < ActionDispatch::IntegrationTest
       response.headers['Set-Cookie'].split("\n")
   end
 
+
+  def test_flag_cookies_as_secure_with_has_not_spaces_before
+    self.app = ActionDispatch::SSL.new(lambda { |env|
+      headers = {
+        'Content-Type' => "text/html",
+        'Set-Cookie' => "problem=def; path=/;secure; HttpOnly"
+      }
+      [200, headers, ["OK"]]
+    })
+
+    get "https://example.org/"
+    assert_equal ["problem=def; path=/;secure; HttpOnly"],
+      response.headers['Set-Cookie'].split("\n")
+  end
+
+  def test_flag_cookies_as_secure_with_has_not_spaces_after
+    self.app = ActionDispatch::SSL.new(lambda { |env|
+      headers = {
+        'Content-Type' => "text/html",
+        'Set-Cookie' => "problem=def; path=/; secure;HttpOnly"
+      }
+      [200, headers, ["OK"]]
+    })
+
+    get "https://example.org/"
+    assert_equal ["problem=def; path=/; secure;HttpOnly"],
+      response.headers['Set-Cookie'].split("\n")
+  end
+
+  def test_flag_cookies_as_secure_with_ignore_case
+    self.app = ActionDispatch::SSL.new(lambda { |env|
+      headers = {
+        'Content-Type' => "text/html",
+        'Set-Cookie' => "problem=def; path=/; Secure; HttpOnly"
+      }
+      [200, headers, ["OK"]]
+    })
+
+    get "https://example.org/"
+    assert_equal ["problem=def; path=/; Secure; HttpOnly"],
+      response.headers['Set-Cookie'].split("\n")
+  end
+
   def test_no_cookies
     self.app = ActionDispatch::SSL.new(lambda { |env|
       [200, {'Content-Type' => "text/html"}, ["OK"]]
diff --git a/actionpack/test/dispatch/static_test.rb b/actionpack/test/dispatch/static_test.rb
index 112f470786..d83461e52f 100644
--- a/actionpack/test/dispatch/static_test.rb
+++ b/actionpack/test/dispatch/static_test.rb
@@ -37,6 +37,10 @@ module StaticTests
   end
 
   def test_served_static_file_with_non_english_filename
+    if RUBY_ENGINE == 'jruby '
+      skip "Stop skipping if following bug gets fixed: " \
+      "http://jira.codehaus.org/browse/JRUBY-7192"
+    end
     assert_html "means hello in Japanese\n", get("/foo/#{Rack::Utils.escape("こんにちは.html")}")
   end
 
@@ -133,7 +137,7 @@ module StaticTests
     end
 
     def with_static_file(file)
-      path = "#{FIXTURE_LOAD_PATH}/public" + file
+      path = "#{FIXTURE_LOAD_PATH}/#{public_path}" + file
       File.open(path, "wb+") { |f| f.write(file) }
       yield file
     ensure
@@ -145,11 +149,24 @@ class StaticTest < ActiveSupport::TestCase
   DummyApp = lambda { |env|
     [200, {"Content-Type" => "text/plain"}, ["Hello, World!"]]
   }
-  App = ActionDispatch::Static.new(DummyApp, "#{FIXTURE_LOAD_PATH}/public", "public, max-age=60")
 
   def setup
-    @app = App
+    @app = ActionDispatch::Static.new(DummyApp, "#{FIXTURE_LOAD_PATH}/public", "public, max-age=60")
+  end
+
+  def public_path
+    "public"
   end
 
   include StaticTests
 end
+
+class StaticEncodingTest < StaticTest
+  def setup
+    @app = ActionDispatch::Static.new(DummyApp, "#{FIXTURE_LOAD_PATH}/公共", "public, max-age=60")
+  end
+
+  def public_path
+    "公共"
+  end
+end
diff --git a/actionpack/test/dispatch/test_request_test.rb b/actionpack/test/dispatch/test_request_test.rb
index 3db862c810..65ad8677f3 100644
--- a/actionpack/test/dispatch/test_request_test.rb
+++ b/actionpack/test/dispatch/test_request_test.rb
@@ -62,6 +62,36 @@ class TestRequestTest < ActiveSupport::TestCase
     assert_equal false, req.env.empty?
   end
 
+  test "default remote address is 0.0.0.0" do
+    req = ActionDispatch::TestRequest.new
+    assert_equal '0.0.0.0', req.remote_addr
+  end
+
+  test "allows remote address to be overridden" do
+    req = ActionDispatch::TestRequest.new('REMOTE_ADDR' => '127.0.0.1')
+    assert_equal '127.0.0.1', req.remote_addr
+  end
+
+  test "default host is test.host" do
+    req = ActionDispatch::TestRequest.new
+    assert_equal 'test.host', req.host
+  end
+
+  test "allows host to be overridden" do
+    req = ActionDispatch::TestRequest.new('HTTP_HOST' => 'www.example.com')
+    assert_equal 'www.example.com', req.host
+  end
+
+  test "default user agent is 'Rails Testing'" do
+    req = ActionDispatch::TestRequest.new
+    assert_equal 'Rails Testing', req.user_agent
+  end
+
+  test "allows user agent to be overridden" do
+    req = ActionDispatch::TestRequest.new('HTTP_USER_AGENT' => 'GoogleBot')
+    assert_equal 'GoogleBot', req.user_agent
+  end
+
   private
     def assert_cookies(expected, cookie_jar)
       assert_equal(expected, cookie_jar.instance_variable_get("@cookies"))
diff --git a/actionpack/test/dispatch/url_generation_test.rb b/actionpack/test/dispatch/url_generation_test.rb
index f919592d24..fdea27e2d2 100644
--- a/actionpack/test/dispatch/url_generation_test.rb
+++ b/actionpack/test/dispatch/url_generation_test.rb
@@ -66,7 +66,7 @@ module TestUrlGeneration
       assert_equal "http://www.example.com:8080/foo", foo_url(host: "www.example.com:8080", protocol: "http://")
     end
 
-    test "port option overides the host" do
+    test "port option overrides the host" do
       assert_equal "http://www.example.com:8080/foo", foo_url(host: "www.example.com:8443", protocol: "http://", port: 8080)
     end
 
diff --git a/actionpack/test/fixtures/_top_level_partial.html.erb b/actionpack/test/fixtures/_top_level_partial.html.erb
deleted file mode 100644
index 0b1c2e46e0..0000000000
--- a/actionpack/test/fixtures/_top_level_partial.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-top level partial html
\ No newline at end of file
diff --git a/actionpack/test/fixtures/blog_public/.gitignore b/actionpack/test/fixtures/blog_public/.gitignore
deleted file mode 100644
index 312e635ee6..0000000000
--- a/actionpack/test/fixtures/blog_public/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-absolute/*
diff --git a/actionpack/test/fixtures/blog_public/blog.html b/actionpack/test/fixtures/blog_public/blog.html
deleted file mode 100644
index 79ad44c010..0000000000
--- a/actionpack/test/fixtures/blog_public/blog.html
+++ /dev/null
@@ -1 +0,0 @@
-/blog/blog.html
\ No newline at end of file
diff --git a/actionpack/test/fixtures/blog_public/index.html b/actionpack/test/fixtures/blog_public/index.html
deleted file mode 100644
index 2de3825481..0000000000
--- a/actionpack/test/fixtures/blog_public/index.html
+++ /dev/null
@@ -1 +0,0 @@
-/blog/index.html
\ No newline at end of file
diff --git a/actionpack/test/fixtures/blog_public/subdir/index.html b/actionpack/test/fixtures/blog_public/subdir/index.html
deleted file mode 100644
index 517bded335..0000000000
--- a/actionpack/test/fixtures/blog_public/subdir/index.html
+++ /dev/null
@@ -1 +0,0 @@
-/blog/subdir/index.html
\ No newline at end of file
diff --git a/actionpack/test/fixtures/comments/empty.de.html.erb b/actionpack/test/fixtures/comments/empty.de.html.erb
deleted file mode 100644
index cffd90dd26..0000000000
--- a/actionpack/test/fixtures/comments/empty.de.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<h1>Kein Kommentar</h1>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/comments/empty.html.builder b/actionpack/test/fixtures/comments/empty.html.builder
deleted file mode 100644
index 2b0c7207a3..0000000000
--- a/actionpack/test/fixtures/comments/empty.html.builder
+++ /dev/null
@@ -1 +0,0 @@
-xml.h1 'No Comment'
\ No newline at end of file
diff --git a/actionpack/test/fixtures/comments/empty.html.erb b/actionpack/test/fixtures/comments/empty.html.erb
deleted file mode 100644
index 827f3861de..0000000000
--- a/actionpack/test/fixtures/comments/empty.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<h1>No Comment</h1>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/comments/empty.xml.erb b/actionpack/test/fixtures/comments/empty.xml.erb
deleted file mode 100644
index db1027cd7d..0000000000
--- a/actionpack/test/fixtures/comments/empty.xml.erb
+++ /dev/null
@@ -1 +0,0 @@
-<error>No Comment</error>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/companies.yml b/actionpack/test/fixtures/companies.yml
deleted file mode 100644
index ed2992e0b1..0000000000
--- a/actionpack/test/fixtures/companies.yml
+++ /dev/null
@@ -1,24 +0,0 @@
-thirty_seven_signals:
-  id: 1
-  name: 37Signals
-  rating: 4
-
-TextDrive:
-  id: 2
-  name: TextDrive
-  rating: 4
-
-PlanetArgon:
-  id: 3
-  name: Planet Argon
-  rating: 4
-
-Google:
-  id: 4
-  name: Google
-  rating: 4
-
-Ionist:
-  id: 5
-  name: Ioni.st
-  rating: 4
\ No newline at end of file
diff --git a/actionpack/test/fixtures/custom_pattern/another.html.erb b/actionpack/test/fixtures/custom_pattern/another.html.erb
deleted file mode 100644
index 6d7f3bafbb..0000000000
--- a/actionpack/test/fixtures/custom_pattern/another.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-Hello custom patterns!
\ No newline at end of file
diff --git a/actionpack/test/fixtures/custom_pattern/html/another.erb b/actionpack/test/fixtures/custom_pattern/html/another.erb
deleted file mode 100644
index dbd7e96ab6..0000000000
--- a/actionpack/test/fixtures/custom_pattern/html/another.erb
+++ /dev/null
@@ -1 +0,0 @@
-Another template!
\ No newline at end of file
diff --git a/actionpack/test/fixtures/custom_pattern/html/path.erb b/actionpack/test/fixtures/custom_pattern/html/path.erb
deleted file mode 100644
index 6d7f3bafbb..0000000000
--- a/actionpack/test/fixtures/custom_pattern/html/path.erb
+++ /dev/null
@@ -1 +0,0 @@
-Hello custom patterns!
\ No newline at end of file
diff --git a/actionpack/test/fixtures/customers/_customer.html.erb b/actionpack/test/fixtures/customers/_customer.html.erb
deleted file mode 100644
index 483571e22a..0000000000
--- a/actionpack/test/fixtures/customers/_customer.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= greeting %>: <%= customer.name %>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/db_definitions/sqlite.sql b/actionpack/test/fixtures/db_definitions/sqlite.sql
deleted file mode 100644
index 99df4b3e61..0000000000
--- a/actionpack/test/fixtures/db_definitions/sqlite.sql
+++ /dev/null
@@ -1,49 +0,0 @@
-CREATE TABLE 'companies' (
-  'id' INTEGER PRIMARY KEY NOT NULL,
-  'name' TEXT DEFAULT NULL,
-  'rating' INTEGER DEFAULT 1
-);
-
-CREATE TABLE 'replies' (
-  'id' INTEGER PRIMARY KEY NOT NULL,
-  'content' text,
-  'created_at' datetime,
-  'updated_at' datetime,
-  'topic_id' integer,
-  'developer_id' integer
-);
-
-CREATE TABLE 'topics' (
-  'id' INTEGER PRIMARY KEY NOT NULL,
-  'title' varchar(255),
-  'subtitle' varchar(255),
-  'content' text,
-  'created_at' datetime,
-  'updated_at' datetime
-);
-
-CREATE TABLE 'developers' (
-  'id' INTEGER PRIMARY KEY NOT NULL,
-  'name' TEXT DEFAULT NULL,
-  'salary' INTEGER DEFAULT 70000,
-  'created_at' DATETIME DEFAULT NULL,
-  'updated_at' DATETIME DEFAULT NULL
-);
-
-CREATE TABLE 'projects' (
-  'id' INTEGER PRIMARY KEY NOT NULL,
-  'name' TEXT DEFAULT NULL
-);
-
-CREATE TABLE 'developers_projects' (
-  'developer_id' INTEGER NOT NULL,
-  'project_id' INTEGER NOT NULL,
-  'joined_on' DATE DEFAULT NULL,
-  'access_level' INTEGER DEFAULT 1
-);
-
-CREATE TABLE 'mascots' (
-  'id' INTEGER PRIMARY KEY NOT NULL,
-  'company_id' INTEGER NOT NULL,
-  'name' TEXT DEFAULT NULL
-);
\ No newline at end of file
diff --git a/actionpack/test/fixtures/developer.rb b/actionpack/test/fixtures/developer.rb
deleted file mode 100644
index 4941463015..0000000000
--- a/actionpack/test/fixtures/developer.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-class Developer < ActiveRecord::Base
-  has_and_belongs_to_many :projects
-  has_many :replies
-  has_many :topics, :through => :replies
-  accepts_nested_attributes_for :projects
-end
-
-class DeVeLoPeR < ActiveRecord::Base
-  self.table_name = "developers"
-end
diff --git a/actionpack/test/fixtures/developers.yml b/actionpack/test/fixtures/developers.yml
deleted file mode 100644
index 3656564f63..0000000000
--- a/actionpack/test/fixtures/developers.yml
+++ /dev/null
@@ -1,21 +0,0 @@
-david:
-  id: 1
-  name: David
-  salary: 80000
-
-jamis:
-  id: 2
-  name: Jamis
-  salary: 150000
-
-<% (3..10).each do |digit| %>
-dev_<%= digit %>:
-  id: <%= digit %>
-  name: fixture_<%= digit %>
-  salary: 100000
-<% end %>
-
-poor_jamis:
-  id: 11
-  name: Jamis
-  salary: 9000
\ No newline at end of file
diff --git a/actionpack/test/fixtures/developers/_developer.erb b/actionpack/test/fixtures/developers/_developer.erb
deleted file mode 100644
index 904a3137e7..0000000000
--- a/actionpack/test/fixtures/developers/_developer.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= developer.name %>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/developers_projects.yml b/actionpack/test/fixtures/developers_projects.yml
deleted file mode 100644
index cee359c7cf..0000000000
--- a/actionpack/test/fixtures/developers_projects.yml
+++ /dev/null
@@ -1,13 +0,0 @@
-david_action_controller:
-  developer_id: 1
-  project_id: 2
-  joined_on: 2004-10-10
-
-david_active_record:
-  developer_id: 1
-  project_id: 1
-  joined_on: 2004-10-10
-
-jamis_active_record:
-  developer_id: 2
-  project_id: 1
\ No newline at end of file
diff --git a/actionpack/test/fixtures/digestor/comments/_comment.html.erb b/actionpack/test/fixtures/digestor/comments/_comment.html.erb
deleted file mode 100644
index f172e749da..0000000000
--- a/actionpack/test/fixtures/digestor/comments/_comment.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-Great story, bro!
diff --git a/actionpack/test/fixtures/digestor/comments/_comments.html.erb b/actionpack/test/fixtures/digestor/comments/_comments.html.erb
deleted file mode 100644
index c28646a283..0000000000
--- a/actionpack/test/fixtures/digestor/comments/_comments.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= render partial: "comments/comment", collection: commentable.comments %>
diff --git a/actionpack/test/fixtures/digestor/level/below/_header.html.erb b/actionpack/test/fixtures/digestor/level/below/_header.html.erb
deleted file mode 100644
index e69de29bb2..0000000000
--- a/actionpack/test/fixtures/digestor/level/below/_header.html.erb
+++ /dev/null
diff --git a/actionpack/test/fixtures/digestor/level/below/index.html.erb b/actionpack/test/fixtures/digestor/level/below/index.html.erb
deleted file mode 100644
index b92f49a8f8..0000000000
--- a/actionpack/test/fixtures/digestor/level/below/index.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= render partial: "header" %>
diff --git a/actionpack/test/fixtures/digestor/messages/_form.html.erb b/actionpack/test/fixtures/digestor/messages/_form.html.erb
deleted file mode 100644
index e69de29bb2..0000000000
--- a/actionpack/test/fixtures/digestor/messages/_form.html.erb
+++ /dev/null
diff --git a/actionpack/test/fixtures/digestor/messages/_header.html.erb b/actionpack/test/fixtures/digestor/messages/_header.html.erb
deleted file mode 100644
index e69de29bb2..0000000000
--- a/actionpack/test/fixtures/digestor/messages/_header.html.erb
+++ /dev/null
diff --git a/actionpack/test/fixtures/digestor/messages/_message.html.erb b/actionpack/test/fixtures/digestor/messages/_message.html.erb
deleted file mode 100644
index 406a0fb848..0000000000
--- a/actionpack/test/fixtures/digestor/messages/_message.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-THIS BE WHERE THEM MESSAGE GO, YO!
\ No newline at end of file
diff --git a/actionpack/test/fixtures/digestor/messages/actions/_move.html.erb b/actionpack/test/fixtures/digestor/messages/actions/_move.html.erb
deleted file mode 100644
index e69de29bb2..0000000000
--- a/actionpack/test/fixtures/digestor/messages/actions/_move.html.erb
+++ /dev/null
diff --git a/actionpack/test/fixtures/digestor/messages/edit.html.erb b/actionpack/test/fixtures/digestor/messages/edit.html.erb
deleted file mode 100644
index a9e0a88e32..0000000000
--- a/actionpack/test/fixtures/digestor/messages/edit.html.erb
+++ /dev/null
@@ -1,5 +0,0 @@
-<%= render              "header" %>
-<%= render    partial:  "form" %>
-<%= render              @message %>
-<%= render ( @message.events ) %>
-<%= render    :partial =>    "comments/comment", :collection => @message.comments %>
diff --git a/actionpack/test/fixtures/digestor/messages/index.html.erb b/actionpack/test/fixtures/digestor/messages/index.html.erb
deleted file mode 100644
index 1937b652e4..0000000000
--- a/actionpack/test/fixtures/digestor/messages/index.html.erb
+++ /dev/null
@@ -1,2 +0,0 @@
-<%= render @messages %>
-<%= render @events %>
diff --git a/actionpack/test/fixtures/digestor/messages/show.html.erb b/actionpack/test/fixtures/digestor/messages/show.html.erb
deleted file mode 100644
index 130e67109e..0000000000
--- a/actionpack/test/fixtures/digestor/messages/show.html.erb
+++ /dev/null
@@ -1,14 +0,0 @@
-<%# Template Dependency: messages/message %>
-<%= render "header" %>
-<%= render "comments/comments" %>
-
-<%= render "messages/actions/move" %>
-
-<%= render @message.history.events %>
-
-<%# render "something_missing"  %>
-<%# render "something_missing_1"  %>
-
-<%
-  # Template Dependency: messages/form
-%>
diff --git a/actionpack/test/fixtures/fun/games/_form.erb b/actionpack/test/fixtures/fun/games/_form.erb
deleted file mode 100644
index 01107f1cb2..0000000000
--- a/actionpack/test/fixtures/fun/games/_form.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= form.label :title %>
diff --git a/actionpack/test/fixtures/fun/games/_game.erb b/actionpack/test/fixtures/fun/games/_game.erb
deleted file mode 100644
index f0f542ff92..0000000000
--- a/actionpack/test/fixtures/fun/games/_game.erb
+++ /dev/null
@@ -1 +0,0 @@
-Fun <%= game.name %>
diff --git a/actionpack/test/fixtures/fun/games/hello_world.erb b/actionpack/test/fixtures/fun/games/hello_world.erb
deleted file mode 100644
index 1ebfbe2539..0000000000
--- a/actionpack/test/fixtures/fun/games/hello_world.erb
+++ /dev/null
@@ -1 +0,0 @@
-Living in a nested world
\ No newline at end of file
diff --git a/actionpack/test/fixtures/fun/serious/games/_game.erb b/actionpack/test/fixtures/fun/serious/games/_game.erb
deleted file mode 100644
index 523bc55bd7..0000000000
--- a/actionpack/test/fixtures/fun/serious/games/_game.erb
+++ /dev/null
@@ -1 +0,0 @@
-Serious <%= game.name %>
diff --git a/actionpack/test/fixtures/games/_game.erb b/actionpack/test/fixtures/games/_game.erb
deleted file mode 100644
index 1aeb81fcba..0000000000
--- a/actionpack/test/fixtures/games/_game.erb
+++ /dev/null
@@ -1 +0,0 @@
-Just <%= game.name %>
diff --git a/actionpack/test/fixtures/good_customers/_good_customer.html.erb b/actionpack/test/fixtures/good_customers/_good_customer.html.erb
deleted file mode 100644
index a2d97ebc6d..0000000000
--- a/actionpack/test/fixtures/good_customers/_good_customer.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= greeting %> good customer: <%= good_customer.name %><%= good_customer_counter %>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/happy_path/render_action/hello_world.erb b/actionpack/test/fixtures/happy_path/render_action/hello_world.erb
deleted file mode 100644
index 6769dd60bd..0000000000
--- a/actionpack/test/fixtures/happy_path/render_action/hello_world.erb
+++ /dev/null
@@ -1 +0,0 @@
-Hello world!
\ No newline at end of file
diff --git a/actionpack/test/fixtures/hello.html b/actionpack/test/fixtures/hello.html
deleted file mode 100644
index 6769dd60bd..0000000000
--- a/actionpack/test/fixtures/hello.html
+++ /dev/null
@@ -1 +0,0 @@
-Hello world!
\ No newline at end of file
diff --git a/actionpack/test/fixtures/helpers/abc_helper.rb b/actionpack/test/fixtures/helpers/abc_helper.rb
index 7104ff3730..cf2774bb5f 100644
--- a/actionpack/test/fixtures/helpers/abc_helper.rb
+++ b/actionpack/test/fixtures/helpers/abc_helper.rb
@@ -1,5 +1,3 @@
 module AbcHelper
   def bare_a() end
-  def bare_b() end
-  def bare_c() end
 end
diff --git a/actionpack/test/fixtures/helpers/helpery_test_helper.rb b/actionpack/test/fixtures/helpers/helpery_test_helper.rb
deleted file mode 100644
index a4f2951efa..0000000000
--- a/actionpack/test/fixtures/helpers/helpery_test_helper.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-module HelperyTestHelper
-  def helpery_test
-    "Default"
-  end
-end
diff --git a/actionpack/test/fixtures/layout_tests/alt/hello.erb b/actionpack/test/fixtures/layout_tests/alt/hello.erb
deleted file mode 100644
index 1055c36659..0000000000
--- a/actionpack/test/fixtures/layout_tests/alt/hello.erb
+++ /dev/null
@@ -1 +0,0 @@
-alt/hello.erb
diff --git a/actionpack/test/fixtures/layout_tests/alt/layouts/alt.erb b/actionpack/test/fixtures/layout_tests/alt/layouts/alt.erb
deleted file mode 100644
index e69de29bb2..0000000000
--- a/actionpack/test/fixtures/layout_tests/alt/layouts/alt.erb
+++ /dev/null
diff --git a/actionpack/test/fixtures/layout_tests/layouts/controller_name_space/nested.erb b/actionpack/test/fixtures/layout_tests/layouts/controller_name_space/nested.erb
deleted file mode 100644
index 121bc079a1..0000000000
--- a/actionpack/test/fixtures/layout_tests/layouts/controller_name_space/nested.erb
+++ /dev/null
@@ -1 +0,0 @@
-controller_name_space/nested.erb <%= yield %>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/layout_tests/layouts/item.erb b/actionpack/test/fixtures/layout_tests/layouts/item.erb
deleted file mode 100644
index 60f04d77d5..0000000000
--- a/actionpack/test/fixtures/layout_tests/layouts/item.erb
+++ /dev/null
@@ -1 +0,0 @@
-item.erb <%= yield %>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/layout_tests/layouts/layout_test.erb b/actionpack/test/fixtures/layout_tests/layouts/layout_test.erb
deleted file mode 100644
index b74ac0840d..0000000000
--- a/actionpack/test/fixtures/layout_tests/layouts/layout_test.erb
+++ /dev/null
@@ -1 +0,0 @@
-layout_test.erb <%= yield %>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/layout_tests/layouts/multiple_extensions.html.erb b/actionpack/test/fixtures/layout_tests/layouts/multiple_extensions.html.erb
deleted file mode 100644
index 3b65e54f9c..0000000000
--- a/actionpack/test/fixtures/layout_tests/layouts/multiple_extensions.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-multiple_extensions.html.erb <%= yield %>
diff --git a/actionpack/test/fixtures/layout_tests/layouts/symlinked b/actionpack/test/fixtures/layout_tests/layouts/symlinked
deleted file mode 120000
index 0ddc1154ab..0000000000
--- a/actionpack/test/fixtures/layout_tests/layouts/symlinked
+++ /dev/null
@@ -1 +0,0 @@
-../../symlink_parent
\ No newline at end of file
diff --git a/actionpack/test/fixtures/layout_tests/layouts/third_party_template_library.mab b/actionpack/test/fixtures/layout_tests/layouts/third_party_template_library.mab
deleted file mode 100644
index fcee620d82..0000000000
--- a/actionpack/test/fixtures/layout_tests/layouts/third_party_template_library.mab
+++ /dev/null
@@ -1 +0,0 @@
-layouts/third_party_template_library.mab
\ No newline at end of file
diff --git a/actionpack/test/fixtures/layout_tests/views/goodbye.erb b/actionpack/test/fixtures/layout_tests/views/goodbye.erb
deleted file mode 100644
index 4ee911188e..0000000000
--- a/actionpack/test/fixtures/layout_tests/views/goodbye.erb
+++ /dev/null
@@ -1 +0,0 @@
-hello.erb
\ No newline at end of file
diff --git a/actionpack/test/fixtures/layout_tests/views/hello.erb b/actionpack/test/fixtures/layout_tests/views/hello.erb
deleted file mode 100644
index 4ee911188e..0000000000
--- a/actionpack/test/fixtures/layout_tests/views/hello.erb
+++ /dev/null
@@ -1 +0,0 @@
-hello.erb
\ No newline at end of file
diff --git a/actionpack/test/fixtures/layouts/_column.html.erb b/actionpack/test/fixtures/layouts/_column.html.erb
deleted file mode 100644
index 96db002b8a..0000000000
--- a/actionpack/test/fixtures/layouts/_column.html.erb
+++ /dev/null
@@ -1,2 +0,0 @@
-<div id="column"><%= yield :column %></div>
-<div id="content"><%= yield %></div>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/layouts/_partial_and_yield.erb b/actionpack/test/fixtures/layouts/_partial_and_yield.erb
deleted file mode 100644
index 74cc428ffa..0000000000
--- a/actionpack/test/fixtures/layouts/_partial_and_yield.erb
+++ /dev/null
@@ -1,2 +0,0 @@
-<%= render :partial => 'test/partial' %>
-<%= yield %>
diff --git a/actionpack/test/fixtures/layouts/_yield_only.erb b/actionpack/test/fixtures/layouts/_yield_only.erb
deleted file mode 100644
index 37f0bddbd7..0000000000
--- a/actionpack/test/fixtures/layouts/_yield_only.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= yield %>
diff --git a/actionpack/test/fixtures/layouts/_yield_with_params.erb b/actionpack/test/fixtures/layouts/_yield_with_params.erb
deleted file mode 100644
index 68e6557fb8..0000000000
--- a/actionpack/test/fixtures/layouts/_yield_with_params.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= yield 'Yield!' %>
diff --git a/actionpack/test/fixtures/layouts/streaming.erb b/actionpack/test/fixtures/layouts/streaming.erb
deleted file mode 100644
index d3f896a6ca..0000000000
--- a/actionpack/test/fixtures/layouts/streaming.erb
+++ /dev/null
@@ -1,4 +0,0 @@
-<%= yield :header -%>
-<%= yield -%>
-<%= yield :footer -%>
-<%= yield(:unknown).presence || "." -%>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/layouts/yield_with_render_inline_inside.erb b/actionpack/test/fixtures/layouts/yield_with_render_inline_inside.erb
deleted file mode 100644
index 7298d79690..0000000000
--- a/actionpack/test/fixtures/layouts/yield_with_render_inline_inside.erb
+++ /dev/null
@@ -1,2 +0,0 @@
-<%= render :inline => 'welcome' %>
-<%= yield %>
diff --git a/actionpack/test/fixtures/layouts/yield_with_render_partial_inside.erb b/actionpack/test/fixtures/layouts/yield_with_render_partial_inside.erb
deleted file mode 100644
index 74cc428ffa..0000000000
--- a/actionpack/test/fixtures/layouts/yield_with_render_partial_inside.erb
+++ /dev/null
@@ -1,2 +0,0 @@
-<%= render :partial => 'test/partial' %>
-<%= yield %>
diff --git a/actionpack/test/fixtures/localized/hello_world.it.erb b/actionpack/test/fixtures/localized/hello_world.it.erb
new file mode 100644
index 0000000000..9191fdc187
--- /dev/null
+++ b/actionpack/test/fixtures/localized/hello_world.it.erb
@@ -0,0 +1 @@
+Ciao Mondo
\ No newline at end of file
diff --git a/actionpack/test/fixtures/mascot.rb b/actionpack/test/fixtures/mascot.rb
deleted file mode 100644
index f9f1448b8f..0000000000
--- a/actionpack/test/fixtures/mascot.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-class Mascot < ActiveRecord::Base
-  belongs_to :company
-end
\ No newline at end of file
diff --git a/actionpack/test/fixtures/mascots.yml b/actionpack/test/fixtures/mascots.yml
deleted file mode 100644
index 17b7dff454..0000000000
--- a/actionpack/test/fixtures/mascots.yml
+++ /dev/null
@@ -1,4 +0,0 @@
-upload_bird:
-  id: 1
-  company_id: 1
-  name: The Upload Bird
\ No newline at end of file
diff --git a/actionpack/test/fixtures/mascots/_mascot.html.erb b/actionpack/test/fixtures/mascots/_mascot.html.erb
deleted file mode 100644
index 432773a1da..0000000000
--- a/actionpack/test/fixtures/mascots/_mascot.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= mascot.name %>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/override/test/hello_world.erb b/actionpack/test/fixtures/override/test/hello_world.erb
deleted file mode 100644
index 3e308d3d86..0000000000
--- a/actionpack/test/fixtures/override/test/hello_world.erb
+++ /dev/null
@@ -1 +0,0 @@
-Hello overridden world!
\ No newline at end of file
diff --git a/actionpack/test/fixtures/override2/layouts/test/sub.erb b/actionpack/test/fixtures/override2/layouts/test/sub.erb
deleted file mode 100644
index 3863d5a8ef..0000000000
--- a/actionpack/test/fixtures/override2/layouts/test/sub.erb
+++ /dev/null
@@ -1 +0,0 @@
-layout: <%= yield %>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/plain_text.raw b/actionpack/test/fixtures/plain_text.raw
deleted file mode 100644
index b13985337f..0000000000
--- a/actionpack/test/fixtures/plain_text.raw
+++ /dev/null
@@ -1 +0,0 @@
-<%= hello_world %>
diff --git a/actionpack/test/fixtures/plain_text_with_characters.raw b/actionpack/test/fixtures/plain_text_with_characters.raw
deleted file mode 100644
index 1e86e44fb4..0000000000
--- a/actionpack/test/fixtures/plain_text_with_characters.raw
+++ /dev/null
@@ -1 +0,0 @@
-Here are some characters: !@#$%^&*()-="'}{`
diff --git a/actionpack/test/fixtures/project.rb b/actionpack/test/fixtures/project.rb
deleted file mode 100644
index c124a9e605..0000000000
--- a/actionpack/test/fixtures/project.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-class Project < ActiveRecord::Base
-  has_and_belongs_to_many :developers, -> { uniq }
-end
diff --git a/actionpack/test/fixtures/projects.yml b/actionpack/test/fixtures/projects.yml
deleted file mode 100644
index 02800c7824..0000000000
--- a/actionpack/test/fixtures/projects.yml
+++ /dev/null
@@ -1,7 +0,0 @@
-action_controller:
-  id: 2
-  name: Active Controller
-
-active_record:
-  id: 1
-  name: Active Record
diff --git a/actionpack/test/fixtures/projects/_project.erb b/actionpack/test/fixtures/projects/_project.erb
deleted file mode 100644
index 480c4c2af3..0000000000
--- a/actionpack/test/fixtures/projects/_project.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= project.name %>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/public/.gitignore b/actionpack/test/fixtures/public/.gitignore
deleted file mode 100644
index 312e635ee6..0000000000
--- a/actionpack/test/fixtures/public/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-absolute/*
diff --git a/actionpack/test/fixtures/public/elsewhere/cools.js b/actionpack/test/fixtures/public/elsewhere/cools.js
deleted file mode 100644
index 6e12fe29c4..0000000000
--- a/actionpack/test/fixtures/public/elsewhere/cools.js
+++ /dev/null
@@ -1 +0,0 @@
-// cools.js
\ No newline at end of file
diff --git a/actionpack/test/fixtures/public/elsewhere/file.css b/actionpack/test/fixtures/public/elsewhere/file.css
deleted file mode 100644
index 6aea0733b1..0000000000
--- a/actionpack/test/fixtures/public/elsewhere/file.css
+++ /dev/null
@@ -1 +0,0 @@
-/*file.css*/
\ No newline at end of file
diff --git a/actionpack/test/fixtures/public/javascripts/application.js b/actionpack/test/fixtures/public/javascripts/application.js
deleted file mode 100644
index 9702692980..0000000000
--- a/actionpack/test/fixtures/public/javascripts/application.js
+++ /dev/null
@@ -1 +0,0 @@
-// application js
\ No newline at end of file
diff --git a/actionpack/test/fixtures/public/javascripts/bank.js b/actionpack/test/fixtures/public/javascripts/bank.js
deleted file mode 100644
index 4a1bee7182..0000000000
--- a/actionpack/test/fixtures/public/javascripts/bank.js
+++ /dev/null
@@ -1 +0,0 @@
-// bank js
\ No newline at end of file
diff --git a/actionpack/test/fixtures/public/javascripts/common.javascript b/actionpack/test/fixtures/public/javascripts/common.javascript
deleted file mode 100644
index 2ae1929056..0000000000
--- a/actionpack/test/fixtures/public/javascripts/common.javascript
+++ /dev/null
@@ -1 +0,0 @@
-// common.javascript
\ No newline at end of file
diff --git a/actionpack/test/fixtures/public/javascripts/controls.js b/actionpack/test/fixtures/public/javascripts/controls.js
deleted file mode 100644
index 88168d9f13..0000000000
--- a/actionpack/test/fixtures/public/javascripts/controls.js
+++ /dev/null
@@ -1 +0,0 @@
-// controls js
\ No newline at end of file
diff --git a/actionpack/test/fixtures/public/javascripts/dragdrop.js b/actionpack/test/fixtures/public/javascripts/dragdrop.js
deleted file mode 100644
index c07061ac0c..0000000000
--- a/actionpack/test/fixtures/public/javascripts/dragdrop.js
+++ /dev/null
@@ -1 +0,0 @@
-// dragdrop js
\ No newline at end of file
diff --git a/actionpack/test/fixtures/public/javascripts/effects.js b/actionpack/test/fixtures/public/javascripts/effects.js
deleted file mode 100644
index b555d63034..0000000000
--- a/actionpack/test/fixtures/public/javascripts/effects.js
+++ /dev/null
@@ -1 +0,0 @@
-// effects js
\ No newline at end of file
diff --git a/actionpack/test/fixtures/public/javascripts/prototype.js b/actionpack/test/fixtures/public/javascripts/prototype.js
deleted file mode 100644
index 9780064a0e..0000000000
--- a/actionpack/test/fixtures/public/javascripts/prototype.js
+++ /dev/null
@@ -1 +0,0 @@
-// prototype js
\ No newline at end of file
diff --git a/actionpack/test/fixtures/public/javascripts/robber.js b/actionpack/test/fixtures/public/javascripts/robber.js
deleted file mode 100644
index eb82fcbdf4..0000000000
--- a/actionpack/test/fixtures/public/javascripts/robber.js
+++ /dev/null
@@ -1 +0,0 @@
-// robber js
\ No newline at end of file
diff --git a/actionpack/test/fixtures/public/javascripts/subdir/subdir.js b/actionpack/test/fixtures/public/javascripts/subdir/subdir.js
deleted file mode 100644
index 9d23a67aa1..0000000000
--- a/actionpack/test/fixtures/public/javascripts/subdir/subdir.js
+++ /dev/null
@@ -1 +0,0 @@
-// subdir js
diff --git a/actionpack/test/fixtures/public/javascripts/version.1.0.js b/actionpack/test/fixtures/public/javascripts/version.1.0.js
deleted file mode 100644
index cfd5fce70e..0000000000
--- a/actionpack/test/fixtures/public/javascripts/version.1.0.js
+++ /dev/null
@@ -1 +0,0 @@
-// version.1.0 js
\ No newline at end of file
diff --git a/actionpack/test/fixtures/public/stylesheets/bank.css b/actionpack/test/fixtures/public/stylesheets/bank.css
deleted file mode 100644
index ea161b12b2..0000000000
--- a/actionpack/test/fixtures/public/stylesheets/bank.css
+++ /dev/null
@@ -1 +0,0 @@
-/* bank.css */
\ No newline at end of file
diff --git a/actionpack/test/fixtures/public/stylesheets/random.styles b/actionpack/test/fixtures/public/stylesheets/random.styles
deleted file mode 100644
index d4eeead95c..0000000000
--- a/actionpack/test/fixtures/public/stylesheets/random.styles
+++ /dev/null
@@ -1 +0,0 @@
-/* random.styles */
\ No newline at end of file
diff --git a/actionpack/test/fixtures/public/stylesheets/robber.css b/actionpack/test/fixtures/public/stylesheets/robber.css
deleted file mode 100644
index 0fdd00a6a5..0000000000
--- a/actionpack/test/fixtures/public/stylesheets/robber.css
+++ /dev/null
@@ -1 +0,0 @@
-/* robber.css */
\ No newline at end of file
diff --git a/actionpack/test/fixtures/public/stylesheets/subdir/subdir.css b/actionpack/test/fixtures/public/stylesheets/subdir/subdir.css
deleted file mode 100644
index 241152a905..0000000000
--- a/actionpack/test/fixtures/public/stylesheets/subdir/subdir.css
+++ /dev/null
@@ -1 +0,0 @@
-/* subdir.css */
diff --git a/actionpack/test/fixtures/public/stylesheets/version.1.0.css b/actionpack/test/fixtures/public/stylesheets/version.1.0.css
deleted file mode 100644
index 30f5f9ba6e..0000000000
--- a/actionpack/test/fixtures/public/stylesheets/version.1.0.css
+++ /dev/null
@@ -1 +0,0 @@
-/* version.1.0.css */
\ No newline at end of file
diff --git a/actionpack/test/fixtures/quiz/questions/_question.html.erb b/actionpack/test/fixtures/quiz/questions/_question.html.erb
deleted file mode 100644
index fb4dcfee64..0000000000
--- a/actionpack/test/fixtures/quiz/questions/_question.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= question.name %>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/replies.yml b/actionpack/test/fixtures/replies.yml
deleted file mode 100644
index 2a3454b8bf..0000000000
--- a/actionpack/test/fixtures/replies.yml
+++ /dev/null
@@ -1,15 +0,0 @@
-witty_retort:
-  id: 1
-  topic_id: 1
-  developer_id: 1
-  content: Birdman is better!
-  created_at: <%= 6.hours.ago.to_s(:db) %>
-  updated_at: nil
-
-another:
-  id: 2
-  topic_id: 2
-  developer_id: 1
-  content: Nuh uh!
-  created_at: <%= 1.hour.ago.to_s(:db) %>
-  updated_at: nil
diff --git a/actionpack/test/fixtures/replies/_reply.erb b/actionpack/test/fixtures/replies/_reply.erb
deleted file mode 100644
index 68baf548d8..0000000000
--- a/actionpack/test/fixtures/replies/_reply.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= reply.content %>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/reply.rb b/actionpack/test/fixtures/reply.rb
deleted file mode 100644
index 047522c55b..0000000000
--- a/actionpack/test/fixtures/reply.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-class Reply < ActiveRecord::Base
-  scope :base, -> { all }
-  belongs_to :topic, -> { includes(:replies) }
-  belongs_to :developer
-
-  validates_presence_of :content
-end
diff --git a/actionpack/test/fixtures/respond_to/variant_any_implicit_render.html+phablet.erb b/actionpack/test/fixtures/respond_to/variant_any_implicit_render.html+phablet.erb
new file mode 100644
index 0000000000..e905d051bf
--- /dev/null
+++ b/actionpack/test/fixtures/respond_to/variant_any_implicit_render.html+phablet.erb
@@ -0,0 +1 @@
+phablet
\ No newline at end of file
diff --git a/actionpack/test/fixtures/respond_to/variant_any_implicit_render.html+tablet.erb b/actionpack/test/fixtures/respond_to/variant_any_implicit_render.html+tablet.erb
new file mode 100644
index 0000000000..65526af8cf
--- /dev/null
+++ b/actionpack/test/fixtures/respond_to/variant_any_implicit_render.html+tablet.erb
@@ -0,0 +1 @@
+tablet
\ No newline at end of file
diff --git a/actionpack/test/fixtures/respond_to/variant_inline_syntax_without_block.html+phone.erb b/actionpack/test/fixtures/respond_to/variant_inline_syntax_without_block.html+phone.erb
new file mode 100644
index 0000000000..cd222a4a49
--- /dev/null
+++ b/actionpack/test/fixtures/respond_to/variant_inline_syntax_without_block.html+phone.erb
@@ -0,0 +1 @@
+phone
\ No newline at end of file
diff --git a/actionpack/test/fixtures/respond_to/variant_plus_none_for_format.html.erb b/actionpack/test/fixtures/respond_to/variant_plus_none_for_format.html.erb
new file mode 100644
index 0000000000..c86c3f3551
--- /dev/null
+++ b/actionpack/test/fixtures/respond_to/variant_plus_none_for_format.html.erb
@@ -0,0 +1 @@
+none
\ No newline at end of file
diff --git a/actionpack/test/fixtures/respond_to/variant_with_implicit_rendering.html+mobile.erb b/actionpack/test/fixtures/respond_to/variant_with_implicit_rendering.html+mobile.erb
new file mode 100644
index 0000000000..317801ad30
--- /dev/null
+++ b/actionpack/test/fixtures/respond_to/variant_with_implicit_rendering.html+mobile.erb
@@ -0,0 +1 @@
+mobile
\ No newline at end of file
diff --git a/actionpack/test/fixtures/digestor/events/_event.html.erb b/actionpack/test/fixtures/respond_with/respond_with_additional_params.html.erb
index e69de29bb2..e69de29bb2 100644
--- a/actionpack/test/fixtures/digestor/events/_event.html.erb
+++ b/actionpack/test/fixtures/respond_with/respond_with_additional_params.html.erb
diff --git a/actionpack/test/fixtures/scope/test/modgreet.erb b/actionpack/test/fixtures/scope/test/modgreet.erb
deleted file mode 100644
index 8947726e89..0000000000
--- a/actionpack/test/fixtures/scope/test/modgreet.erb
+++ /dev/null
@@ -1 +0,0 @@
-<p>Beautiful modules!</p>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/_200.html.erb b/actionpack/test/fixtures/test/_200.html.erb
deleted file mode 100644
index c9f45675dc..0000000000
--- a/actionpack/test/fixtures/test/_200.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<h1>Invalid partial</h1>
diff --git a/actionpack/test/fixtures/test/_b_layout_for_partial.html.erb b/actionpack/test/fixtures/test/_b_layout_for_partial.html.erb
deleted file mode 100644
index e918ba8f83..0000000000
--- a/actionpack/test/fixtures/test/_b_layout_for_partial.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<b><%= yield %></b>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/_b_layout_for_partial_with_object.html.erb b/actionpack/test/fixtures/test/_b_layout_for_partial_with_object.html.erb
deleted file mode 100644
index bdd53014cd..0000000000
--- a/actionpack/test/fixtures/test/_b_layout_for_partial_with_object.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<b class="<%= customer.name.downcase %>"><%= yield %></b>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/_b_layout_for_partial_with_object_counter.html.erb b/actionpack/test/fixtures/test/_b_layout_for_partial_with_object_counter.html.erb
deleted file mode 100644
index 44d6121297..0000000000
--- a/actionpack/test/fixtures/test/_b_layout_for_partial_with_object_counter.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<b data-counter="<%= customer_counter %>"><%= yield %></b>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/_content_tag_nested_in_content_tag.erb b/actionpack/test/fixtures/test/_content_tag_nested_in_content_tag.erb
deleted file mode 100644
index 2f21a75dd9..0000000000
--- a/actionpack/test/fixtures/test/_content_tag_nested_in_content_tag.erb
+++ /dev/null
@@ -1,3 +0,0 @@
-<%= content_tag 'p' do %>
-  <%= content_tag 'b', 'Hello' %>
-<% end %>
diff --git a/actionpack/test/fixtures/test/_from_helper.erb b/actionpack/test/fixtures/test/_from_helper.erb
deleted file mode 100644
index 16de7c0f8a..0000000000
--- a/actionpack/test/fixtures/test/_from_helper.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= render_from_helper %>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/_label_with_block.erb b/actionpack/test/fixtures/test/_label_with_block.erb
deleted file mode 100644
index 40117e594e..0000000000
--- a/actionpack/test/fixtures/test/_label_with_block.erb
+++ /dev/null
@@ -1,4 +0,0 @@
-<%= label 'post', 'message' do %>
-  Message
-  <%= text_field 'post', 'message' %>
-<% end %>
diff --git a/actionpack/test/fixtures/test/_layout_for_block_with_args.html.erb b/actionpack/test/fixtures/test/_layout_for_block_with_args.html.erb
deleted file mode 100644
index 307533208d..0000000000
--- a/actionpack/test/fixtures/test/_layout_for_block_with_args.html.erb
+++ /dev/null
@@ -1,3 +0,0 @@
-Before
-<%= yield 'arg1', 'arg2' %>
-After
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/_layout_with_partial_and_yield.html.erb b/actionpack/test/fixtures/test/_layout_with_partial_and_yield.html.erb
deleted file mode 100644
index 820e7db789..0000000000
--- a/actionpack/test/fixtures/test/_layout_with_partial_and_yield.html.erb
+++ /dev/null
@@ -1,4 +0,0 @@
-Before
-<%= render :partial => "test/partial" %>
-<%= yield %>
-After
diff --git a/actionpack/test/fixtures/test/_local_inspector.html.erb b/actionpack/test/fixtures/test/_local_inspector.html.erb
deleted file mode 100644
index e6765c0882..0000000000
--- a/actionpack/test/fixtures/test/_local_inspector.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= local_assigns.keys.map {|k| k.to_s }.sort.join(",") -%>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/_object_inspector.erb b/actionpack/test/fixtures/test/_object_inspector.erb
deleted file mode 100644
index 53af593821..0000000000
--- a/actionpack/test/fixtures/test/_object_inspector.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= object_inspector.inspect -%>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/_one.html.erb b/actionpack/test/fixtures/test/_one.html.erb
deleted file mode 100644
index f796291cb4..0000000000
--- a/actionpack/test/fixtures/test/_one.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= render :partial => "two" %> world
diff --git a/actionpack/test/fixtures/test/_partial_with_layout.erb b/actionpack/test/fixtures/test/_partial_with_layout.erb
deleted file mode 100644
index 2a50c834fe..0000000000
--- a/actionpack/test/fixtures/test/_partial_with_layout.erb
+++ /dev/null
@@ -1,2 +0,0 @@
-<%= render :partial => 'test/partial', :layout => 'test/layout_for_partial', :locals => { :name => 'Bar!' } %>
-partial with layout
diff --git a/actionpack/test/fixtures/test/_partial_with_layout_block_content.erb b/actionpack/test/fixtures/test/_partial_with_layout_block_content.erb
deleted file mode 100644
index 65dafd93a8..0000000000
--- a/actionpack/test/fixtures/test/_partial_with_layout_block_content.erb
+++ /dev/null
@@ -1,4 +0,0 @@
-<%= render :layout => 'test/layout_for_partial', :locals => { :name => 'Bar!' } do %>
-  Content from inside layout!
-<% end %>
-partial with layout
diff --git a/actionpack/test/fixtures/test/_partial_with_layout_block_partial.erb b/actionpack/test/fixtures/test/_partial_with_layout_block_partial.erb
deleted file mode 100644
index 444197a7d0..0000000000
--- a/actionpack/test/fixtures/test/_partial_with_layout_block_partial.erb
+++ /dev/null
@@ -1,4 +0,0 @@
-<%= render :layout => 'test/layout_for_partial', :locals => { :name => 'Bar!' } do %>
-  <%= render 'test/partial' %>
-<% end %>
-partial with layout
diff --git a/actionpack/test/fixtures/test/_partial_with_only_html_version.html.erb b/actionpack/test/fixtures/test/_partial_with_only_html_version.html.erb
deleted file mode 100644
index 00e6b6d6da..0000000000
--- a/actionpack/test/fixtures/test/_partial_with_only_html_version.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-partial with only html version
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/_raise.html.erb b/actionpack/test/fixtures/test/_raise.html.erb
deleted file mode 100644
index 68b08181d3..0000000000
--- a/actionpack/test/fixtures/test/_raise.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= doesnt_exist %>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/_two.html.erb b/actionpack/test/fixtures/test/_two.html.erb
deleted file mode 100644
index 5ab2f8a432..0000000000
--- a/actionpack/test/fixtures/test/_two.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-Hello
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/_utf8_partial.html.erb b/actionpack/test/fixtures/test/_utf8_partial.html.erb
deleted file mode 100644
index 8d717fd427..0000000000
--- a/actionpack/test/fixtures/test/_utf8_partial.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= "текст" %>
diff --git a/actionpack/test/fixtures/test/_utf8_partial_magic.html.erb b/actionpack/test/fixtures/test/_utf8_partial_magic.html.erb
deleted file mode 100644
index 4e2224610a..0000000000
--- a/actionpack/test/fixtures/test/_utf8_partial_magic.html.erb
+++ /dev/null
@@ -1,2 +0,0 @@
-<%# encoding: utf-8 -%>
-<%= "текст" %>
diff --git a/actionpack/test/fixtures/test/basic.html.erb b/actionpack/test/fixtures/test/basic.html.erb
deleted file mode 100644
index ea696d7e01..0000000000
--- a/actionpack/test/fixtures/test/basic.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-Hello from basic.html.erb
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/dont_pick_me b/actionpack/test/fixtures/test/dont_pick_me
deleted file mode 100644
index 0157c9e503..0000000000
--- a/actionpack/test/fixtures/test/dont_pick_me
+++ /dev/null
@@ -1 +0,0 @@
-non-template file
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/hello_world.da.html.erb b/actionpack/test/fixtures/test/hello_world.da.html.erb
deleted file mode 100644
index 10ec443291..0000000000
--- a/actionpack/test/fixtures/test/hello_world.da.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-Hey verden
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/hello_world.erb~ b/actionpack/test/fixtures/test/hello_world.erb~
deleted file mode 100644
index 21934a1c95..0000000000
--- a/actionpack/test/fixtures/test/hello_world.erb~
+++ /dev/null
@@ -1 +0,0 @@
-Don't pick me!
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/hello_world.pt-BR.html.erb b/actionpack/test/fixtures/test/hello_world.pt-BR.html.erb
deleted file mode 100644
index 773b3c8c6e..0000000000
--- a/actionpack/test/fixtures/test/hello_world.pt-BR.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-Ola mundo
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/layout_render_file.erb b/actionpack/test/fixtures/test/layout_render_file.erb
deleted file mode 100644
index 2f8e921c5f..0000000000
--- a/actionpack/test/fixtures/test/layout_render_file.erb
+++ /dev/null
@@ -1,2 +0,0 @@
-<% content_for :title do %>title<% end -%>
-<%= render :file => 'layouts/yield' -%>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/layout_render_object.erb b/actionpack/test/fixtures/test/layout_render_object.erb
deleted file mode 100644
index acc4453c08..0000000000
--- a/actionpack/test/fixtures/test/layout_render_object.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= render :layout => "layouts/customers" do |customer| %><%= customer.name %><% end %>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/malformed/malformed.en.html.erb~ b/actionpack/test/fixtures/test/malformed/malformed.en.html.erb~
deleted file mode 100644
index d009950384..0000000000
--- a/actionpack/test/fixtures/test/malformed/malformed.en.html.erb~
+++ /dev/null
@@ -1 +0,0 @@
-Don't render me!
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/malformed/malformed.erb~ b/actionpack/test/fixtures/test/malformed/malformed.erb~
deleted file mode 100644
index d009950384..0000000000
--- a/actionpack/test/fixtures/test/malformed/malformed.erb~
+++ /dev/null
@@ -1 +0,0 @@
-Don't render me!
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/malformed/malformed.html.erb~ b/actionpack/test/fixtures/test/malformed/malformed.html.erb~
deleted file mode 100644
index d009950384..0000000000
--- a/actionpack/test/fixtures/test/malformed/malformed.html.erb~
+++ /dev/null
@@ -1 +0,0 @@
-Don't render me!
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/nested_layout.erb b/actionpack/test/fixtures/test/nested_layout.erb
deleted file mode 100644
index 6078f74b4c..0000000000
--- a/actionpack/test/fixtures/test/nested_layout.erb
+++ /dev/null
@@ -1,3 +0,0 @@
-<% content_for :title, "title" -%>
-<% content_for :column do -%>column<% end -%>
-<%= render :layout => 'layouts/column' do -%>content<% end -%>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/nested_streaming.erb b/actionpack/test/fixtures/test/nested_streaming.erb
deleted file mode 100644
index 55525e0c92..0000000000
--- a/actionpack/test/fixtures/test/nested_streaming.erb
+++ /dev/null
@@ -1,3 +0,0 @@
-<%- content_for :header do -%>?<%- end -%>
-<%= render :template => "test/streaming" %>
-?
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/one.html.erb b/actionpack/test/fixtures/test/one.html.erb
deleted file mode 100644
index 0151874809..0000000000
--- a/actionpack/test/fixtures/test/one.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= render :partial => "test/two" %> world
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/streaming.erb b/actionpack/test/fixtures/test/streaming.erb
deleted file mode 100644
index fb9b8b1ade..0000000000
--- a/actionpack/test/fixtures/test/streaming.erb
+++ /dev/null
@@ -1,3 +0,0 @@
-<%- provide :header do -%>Yes, <%- end -%>
-this works
-<%- content_for :footer, " like a charm" -%>
diff --git a/actionpack/test/fixtures/test/streaming_buster.erb b/actionpack/test/fixtures/test/streaming_buster.erb
deleted file mode 100644
index 4221d56dcc..0000000000
--- a/actionpack/test/fixtures/test/streaming_buster.erb
+++ /dev/null
@@ -1,3 +0,0 @@
-<%= yield :foo -%>
-This won't look
-<% provide :unknown, " good." -%>
diff --git a/actionpack/test/fixtures/test/sub_template_raise.html.erb b/actionpack/test/fixtures/test/sub_template_raise.html.erb
deleted file mode 100644
index f38c0bda90..0000000000
--- a/actionpack/test/fixtures/test/sub_template_raise.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= render :partial => "test/raise" %>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/template.erb b/actionpack/test/fixtures/test/template.erb
deleted file mode 100644
index 785afa8f6a..0000000000
--- a/actionpack/test/fixtures/test/template.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= template.path %>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/update_element_with_capture.erb b/actionpack/test/fixtures/test/update_element_with_capture.erb
deleted file mode 100644
index fa3ef200f9..0000000000
--- a/actionpack/test/fixtures/test/update_element_with_capture.erb
+++ /dev/null
@@ -1,9 +0,0 @@
-<% replacement_function = update_element_function("products", :action => :update) do %>
-  <p>Product 1</p>
-  <p>Product 2</p>
-<% end %>
-<%= javascript_tag(replacement_function) %>
-
-<% update_element_function("status", :action => :update, :binding => binding) do %>
-  <b>You bought something!</b>
-<% end %>
diff --git a/actionpack/test/fixtures/test/utf8.html.erb b/actionpack/test/fixtures/test/utf8.html.erb
deleted file mode 100644
index ac98c2f012..0000000000
--- a/actionpack/test/fixtures/test/utf8.html.erb
+++ /dev/null
@@ -1,4 +0,0 @@
-Русский <%= render :partial => 'test/utf8_partial' %>
-<%= "日".encoding %>
-<%= @output_buffer.encoding %>
-<%= __ENCODING__ %>
diff --git a/actionpack/test/fixtures/test/utf8_magic.html.erb b/actionpack/test/fixtures/test/utf8_magic.html.erb
deleted file mode 100644
index 257279c29f..0000000000
--- a/actionpack/test/fixtures/test/utf8_magic.html.erb
+++ /dev/null
@@ -1,5 +0,0 @@
-<%# encoding: utf-8 -%>
-Русский <%= render :partial => 'test/utf8_partial_magic' %>
-<%= "日".encoding %>
-<%= @output_buffer.encoding %>
-<%= __ENCODING__ %>
diff --git a/actionpack/test/fixtures/test/utf8_magic_with_bare_partial.html.erb b/actionpack/test/fixtures/test/utf8_magic_with_bare_partial.html.erb
deleted file mode 100644
index cb22692f9a..0000000000
--- a/actionpack/test/fixtures/test/utf8_magic_with_bare_partial.html.erb
+++ /dev/null
@@ -1,5 +0,0 @@
-<%# encoding: utf-8 -%>
-Русский <%= render :partial => 'test/utf8_partial' %>
-<%= "日".encoding %>
-<%= @output_buffer.encoding %>
-<%= __ENCODING__ %>
diff --git a/actionpack/test/fixtures/topic.rb b/actionpack/test/fixtures/topic.rb
deleted file mode 100644
index 9fa9746535..0000000000
--- a/actionpack/test/fixtures/topic.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-class Topic < ActiveRecord::Base
-  has_many :replies, :dependent => :destroy
-end
diff --git a/actionpack/test/fixtures/topics.yml b/actionpack/test/fixtures/topics.yml
deleted file mode 100644
index 7fdd49d54e..0000000000
--- a/actionpack/test/fixtures/topics.yml
+++ /dev/null
@@ -1,22 +0,0 @@
-futurama:
-  id: 1
-  title: Isnt futurama awesome?
-  subtitle: It really is, isnt it.
-  content: I like futurama
-  created_at: <%= 1.day.ago.to_s(:db) %>
-  updated_at:
-
-harvey_birdman:
-  id: 2
-  title: Harvey Birdman is the king of all men
-  subtitle: yup
-  content: It really is
-  created_at: <%= 2.hours.ago.to_s(:db) %>
-  updated_at:
-
-rails:
-  id: 3
-  title: Rails is nice
-  subtitle: It makes me happy
-  content: except when I have to hack internals to fix pagination. even then really.
-  created_at: <%= 20.minutes.ago.to_s(:db) %>
diff --git a/actionpack/test/fixtures/topics/_topic.html.erb b/actionpack/test/fixtures/topics/_topic.html.erb
deleted file mode 100644
index 98659ca098..0000000000
--- a/actionpack/test/fixtures/topics/_topic.html.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= topic.title %>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/translations/templates/array.erb b/actionpack/test/fixtures/translations/templates/array.erb
deleted file mode 100644
index d86045a172..0000000000
--- a/actionpack/test/fixtures/translations/templates/array.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= t('.foo.bar') %>
diff --git a/actionpack/test/fixtures/translations/templates/default.erb b/actionpack/test/fixtures/translations/templates/default.erb
deleted file mode 100644
index 8b70031071..0000000000
--- a/actionpack/test/fixtures/translations/templates/default.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= t('.missing', :default => :'.foo') %>
diff --git a/actionpack/test/fixtures/translations/templates/found.erb b/actionpack/test/fixtures/translations/templates/found.erb
deleted file mode 100644
index 080c9c0aee..0000000000
--- a/actionpack/test/fixtures/translations/templates/found.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= t('.foo') %>
diff --git a/actionpack/test/fixtures/translations/templates/missing.erb b/actionpack/test/fixtures/translations/templates/missing.erb
deleted file mode 100644
index 0f3f17f8ef..0000000000
--- a/actionpack/test/fixtures/translations/templates/missing.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= t('.missing') %>
diff --git a/actionpack/test/fixtures/with_format.json.erb b/actionpack/test/fixtures/with_format.json.erb
deleted file mode 100644
index a7f480ab1d..0000000000
--- a/actionpack/test/fixtures/with_format.json.erb
+++ /dev/null
@@ -1 +0,0 @@
-<%= render :partial => 'missing', :formats => [:json] %>
diff --git a/actionpack/test/fixtures/公共/foo/bar.html b/actionpack/test/fixtures/公共/foo/bar.html
new file mode 100644
index 0000000000..9a35646205
--- /dev/null
+++ b/actionpack/test/fixtures/公共/foo/bar.html
@@ -0,0 +1 @@
+/foo/bar.html
\ No newline at end of file
diff --git a/actionpack/test/fixtures/公共/foo/baz.css b/actionpack/test/fixtures/公共/foo/baz.css
new file mode 100644
index 0000000000..b5173fbef2
--- /dev/null
+++ b/actionpack/test/fixtures/公共/foo/baz.css
@@ -0,0 +1,3 @@
+body {
+background: #000;
+}
diff --git a/actionpack/test/fixtures/公共/foo/index.html b/actionpack/test/fixtures/公共/foo/index.html
new file mode 100644
index 0000000000..497a2e898f
--- /dev/null
+++ b/actionpack/test/fixtures/公共/foo/index.html
@@ -0,0 +1 @@
+/foo/index.html
\ No newline at end of file
diff --git a/actionpack/test/fixtures/公共/foo/こんにちは.html b/actionpack/test/fixtures/公共/foo/こんにちは.html
new file mode 100644
index 0000000000..1df9166522
--- /dev/null
+++ b/actionpack/test/fixtures/公共/foo/こんにちは.html
@@ -0,0 +1 @@
+means hello in Japanese
diff --git a/actionpack/test/fixtures/公共/index.html b/actionpack/test/fixtures/公共/index.html
new file mode 100644
index 0000000000..525950ba6b
--- /dev/null
+++ b/actionpack/test/fixtures/公共/index.html
@@ -0,0 +1 @@
+/index.html
\ No newline at end of file
diff --git a/actionpack/test/journey/gtg/transition_table_test.rb b/actionpack/test/journey/gtg/transition_table_test.rb
index 33acba8b65..b968780d8d 100644
--- a/actionpack/test/journey/gtg/transition_table_test.rb
+++ b/actionpack/test/journey/gtg/transition_table_test.rb
@@ -1,5 +1,5 @@
 require 'abstract_unit'
-require 'json'
+require 'active_support/json/decoding'
 
 module ActionDispatch
   module Journey
@@ -13,7 +13,7 @@ module ActionDispatch
             /articles/:id(.:format)
           }
 
-          json = JSON.load table.to_json
+          json = ActiveSupport::JSON.decode table.to_json
           assert json['regexp_states']
           assert json['string_states']
           assert json['accepting']
diff --git a/actionpack/test/journey/router/utils_test.rb b/actionpack/test/journey/router/utils_test.rb
index 057dc40cca..93348f4647 100644
--- a/actionpack/test/journey/router/utils_test.rb
+++ b/actionpack/test/journey/router/utils_test.rb
@@ -15,6 +15,14 @@ module ActionDispatch
         def test_uri_unescape
           assert_equal "a/b c+d", Utils.unescape_uri("a%2Fb%20c+d")
         end
+
+        def test_normalize_path_not_greedy
+          assert_equal "/foo%20bar%20baz", Utils.normalize_path("/foo%20bar%20baz")
+        end
+
+        def test_normalize_path_uppercase
+          assert_equal "/foo%AAbar%AAbaz", Utils.normalize_path("/foo%aabar%aabaz")
+        end
       end
     end
   end
diff --git a/actionpack/test/journey/router_test.rb b/actionpack/test/journey/router_test.rb
index 3d52b2e9ee..a286f77633 100644
--- a/actionpack/test/journey/router_test.rb
+++ b/actionpack/test/journey/router_test.rb
@@ -4,9 +4,13 @@ require 'abstract_unit'
 module ActionDispatch
   module Journey
     class TestRouter < ActiveSupport::TestCase
+      # TODO : clean up routing tests so we don't need this hack
+      class StubDispatcher < Routing::RouteSet::Dispatcher; end
+
       attr_reader :routes
 
       def setup
+        @app       = StubDispatcher.new
         @routes    = Routes.new
         @router    = Router.new(@routes, {})
         @formatter = Formatter.new(@routes)
@@ -306,7 +310,7 @@ module ActionDispatch
 
       def test_nil_path_parts_are_ignored
         path  = Path::Pattern.new "/:controller(/:action(.:format))"
-        @router.routes.add_route nil, path, {}, {}, {}
+        @router.routes.add_route @app, path, {}, {}, {}
 
         params = { :controller => "tasks", :format => nil }
         extras = { :action => 'lol' }
@@ -321,7 +325,7 @@ module ActionDispatch
         str = Router::Strexp.new("/", Hash[params], ['/', '.', '?'], true)
         path  = Path::Pattern.new str
 
-        @router.routes.add_route nil, path, {}, {}, {}
+        @router.routes.add_route @app, path, {}, {}, {}
 
         path, _ = @formatter.generate(:path_info, nil, Hash[params], {})
         assert_equal '/', path
@@ -329,7 +333,7 @@ module ActionDispatch
 
       def test_generate_calls_param_proc
         path  = Path::Pattern.new '/:controller(/:action)'
-        @router.routes.add_route nil, path, {}, {}, {}
+        @router.routes.add_route @app, path, {}, {}, {}
 
         parameterized = []
         params = [ [:controller, "tasks"],
@@ -347,7 +351,7 @@ module ActionDispatch
 
       def test_generate_id
         path  = Path::Pattern.new '/:controller(/:action)'
-        @router.routes.add_route nil, path, {}, {}, {}
+        @router.routes.add_route @app, path, {}, {}, {}
 
         path, params = @formatter.generate(
           :path_info, nil, {:id=>1, :controller=>"tasks", :action=>"show"}, {})
@@ -357,7 +361,7 @@ module ActionDispatch
 
       def test_generate_escapes
         path  = Path::Pattern.new '/:controller(/:action)'
-        @router.routes.add_route nil, path, {}, {}, {}
+        @router.routes.add_route @app, path, {}, {}, {}
 
         path, _ = @formatter.generate(:path_info,
           nil, { :controller        => "tasks",
@@ -368,7 +372,7 @@ module ActionDispatch
 
       def test_generate_extra_params
         path  = Path::Pattern.new '/:controller(/:action)'
-        @router.routes.add_route nil, path, {}, {}, {}
+        @router.routes.add_route @app, path, {}, {}, {}
 
         path, params = @formatter.generate(:path_info,
           nil, { :id                => 1,
@@ -382,7 +386,7 @@ module ActionDispatch
 
       def test_generate_uses_recall_if_needed
         path  = Path::Pattern.new '/:controller(/:action(/:id))'
-        @router.routes.add_route nil, path, {}, {}, {}
+        @router.routes.add_route @app, path, {}, {}, {}
 
         path, params = @formatter.generate(:path_info,
           nil,
@@ -394,7 +398,7 @@ module ActionDispatch
 
       def test_generate_with_name
         path  = Path::Pattern.new '/:controller(/:action)'
-        @router.routes.add_route nil, path, {}, {}, {}
+        @router.routes.add_route @app, path, {}, {}, {}
 
         path, params = @formatter.generate(:path_info,
           "tasks",
@@ -541,7 +545,7 @@ module ActionDispatch
       def add_routes router, paths
         paths.each do |path|
           path  = Path::Pattern.new path
-          router.routes.add_route nil, path, {}, {}, {}
+          router.routes.add_route @app, path, {}, {}, {}
         end
       end
 
diff --git a/actionpack/test/lib/controller/fake_models.rb b/actionpack/test/lib/controller/fake_models.rb
index 82f38b5309..b8b51d86c2 100644
--- a/actionpack/test/lib/controller/fake_models.rb
+++ b/actionpack/test/lib/controller/fake_models.rb
@@ -28,12 +28,6 @@ class Customer < Struct.new(:name, :id)
   end
 end
 
-class BadCustomer < Customer
-end
-
-class GoodCustomer < Customer
-end
-
 class ValidatedCustomer < Customer
   def errors
     if name =~ /Sikachu/i
@@ -102,88 +96,6 @@ class Comment
   attr_accessor :body
 end
 
-class Tag
-  extend ActiveModel::Naming
-  include ActiveModel::Conversion
-
-  attr_reader :id
-  attr_reader :post_id
-  def initialize(id = nil, post_id = nil); @id, @post_id = id, post_id end
-  def to_key; id ? [id] : nil end
-  def save; @id = 1; @post_id = 1 end
-  def persisted?; @id.present? end
-  def to_param; @id; end
-  def value
-    @id.nil? ? "new #{self.class.name.downcase}" : "#{self.class.name.downcase} ##{@id}"
-  end
-
-  attr_accessor :relevances
-  def relevances_attributes=(attributes); end
-
-end
-
-class CommentRelevance
-  extend ActiveModel::Naming
-  include ActiveModel::Conversion
-
-  attr_reader :id
-  attr_reader :comment_id
-  def initialize(id = nil, comment_id = nil); @id, @comment_id = id, comment_id end
-  def to_key; id ? [id] : nil end
-  def save; @id = 1; @comment_id = 1 end
-  def persisted?; @id.present? end
-  def to_param; @id; end
-  def value
-    @id.nil? ? "new #{self.class.name.downcase}" : "#{self.class.name.downcase} ##{@id}"
-  end
-end
-
-class Sheep
-  extend ActiveModel::Naming
-  include ActiveModel::Conversion
-
-  attr_reader :id
-  def to_key; id ? [id] : nil end
-  def save; @id = 1 end
-  def new_record?; @id.nil? end
-  def name
-    @id.nil? ? 'new sheep' : "sheep ##{@id}"
-  end
-end
-
-
-class TagRelevance
-  extend ActiveModel::Naming
-  include ActiveModel::Conversion
-
-  attr_reader :id
-  attr_reader :tag_id
-  def initialize(id = nil, tag_id = nil); @id, @tag_id = id, tag_id end
-  def to_key; id ? [id] : nil end
-  def save; @id = 1; @tag_id = 1 end
-  def persisted?; @id.present? end
-  def to_param; @id; end
-  def value
-    @id.nil? ? "new #{self.class.name.downcase}" : "#{self.class.name.downcase} ##{@id}"
-  end
-end
-
-class Author < Comment
-  attr_accessor :post
-  def post_attributes=(attributes); end
-end
-
-class HashBackedAuthor < Hash
-  extend ActiveModel::Naming
-  include ActiveModel::Conversion
-
-  def persisted?; false; end
-
-  def name
-    "hash backed author"
-  end
-end
-
 module Blog
   def self.use_relative_model_naming?
     true
@@ -199,21 +111,8 @@ module Blog
   end
 end
 
-class ArelLike
-  def to_ary
-    true
-  end
-  def each
-    a = Array.new(2) { |id| Comment.new(id + 1) }
-    a.each { |i| yield i }
-  end
-end
-
 class RenderJsonTestException < Exception
-  def to_json(options = nil)
-    return { :error => self.class.name, :message => self.to_s }.to_json
+  def as_json(options = nil)
+    { :error => self.class.name, :message => self.to_s }
   end
 end
-
-class Car < Struct.new(:color)
-end
diff --git a/actionpack/test/routing/helper_test.rb b/actionpack/test/routing/helper_test.rb
index a5588d95fa..0028aaa629 100644
--- a/actionpack/test/routing/helper_test.rb
+++ b/actionpack/test/routing/helper_test.rb
@@ -22,7 +22,7 @@ module ActionDispatch
         x = Class.new {
           include rs.url_helpers
         }
-        assert_raises ActionController::RoutingError do
+        assert_raises ActionController::UrlGenerationError do
           x.new.pond_duck_path Duck.new
         end
       end
diff --git a/actionpack/test/template/active_model_helper_test.rb b/actionpack/test/template/active_model_helper_test.rb
deleted file mode 100644
index 86bccdfade..0000000000
--- a/actionpack/test/template/active_model_helper_test.rb
+++ /dev/null
@@ -1,99 +0,0 @@
-require 'abstract_unit'
-
-class ActiveModelHelperTest < ActionView::TestCase
-  tests ActionView::Helpers::ActiveModelHelper
-
-  silence_warnings do
-    class Post < Struct.new(:author_name, :body, :updated_at)
-      include ActiveModel::Conversion
-      include ActiveModel::Validations
-
-      def persisted?
-        false
-      end
-    end
-  end
-
-  def setup
-    super
-
-    @post = Post.new
-    @post.errors[:author_name] << "can't be empty"
-    @post.errors[:body] << "foo"
-    @post.errors[:updated_at] << "bar"
-
-    @post.author_name = ""
-    @post.body        = "Back to the hill and over it again!"
-    @post.updated_at  = Date.new(2004, 6, 15)
-  end
-
-  def test_text_area_with_errors
-    assert_dom_equal(
-      %(<div class="field_with_errors"><textarea id="post_body" name="post[body]">\nBack to the hill and over it again!</textarea></div>),
-      text_area("post", "body")
-    )
-  end
-
-  def test_text_field_with_errors
-    assert_dom_equal(
-      %(<div class="field_with_errors"><input id="post_author_name" name="post[author_name]" type="text" value="" /></div>),
-      text_field("post", "author_name")
-    )
-  end
-
-  def test_select_with_errors
-    assert_dom_equal(
-      %(<div class="field_with_errors"><select name="post[author_name]" id="post_author_name"><option value="a">a</option>\n<option value="b">b</option></select></div>),
-      select("post", "author_name", [:a, :b])
-    )
-  end
-
-  def test_select_with_errors_and_blank_option
-    expected_dom = %(<div class="field_with_errors"><select name="post[author_name]" id="post_author_name"><option value="">Choose one...</option>\n<option value="a">a</option>\n<option value="b">b</option></select></div>)
-    assert_dom_equal(expected_dom, select("post", "author_name", [:a, :b], :include_blank => 'Choose one...'))
-    assert_dom_equal(expected_dom, select("post", "author_name", [:a, :b], :prompt => 'Choose one...'))
-  end
-
-  def test_date_select_with_errors
-    assert_dom_equal(
-      %(<div class="field_with_errors"><select id="post_updated_at_1i" name="post[updated_at(1i)]">\n<option selected="selected" value="2004">2004</option>\n<option value="2005">2005</option>\n</select>\n<input id="post_updated_at_2i" name="post[updated_at(2i)]" type="hidden" value="6" />\n<input id="post_updated_at_3i" name="post[updated_at(3i)]" type="hidden" value="1" />\n</div>),
-      date_select("post", "updated_at", :discard_month => true, :discard_day => true, :start_year => 2004, :end_year => 2005)
-    )
-  end
-
-  def test_datetime_select_with_errors
-    assert_dom_equal(
-      %(<div class="field_with_errors"><input id="post_updated_at_1i" name="post[updated_at(1i)]" type="hidden" value="2004" />\n<input id="post_updated_at_2i" name="post[updated_at(2i)]" type="hidden" value="6" />\n<input id="post_updated_at_3i" name="post[updated_at(3i)]" type="hidden" value="1" />\n<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n<option selected="selected" value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n</select>\n : <select id="post_updated_at_5i" name="post[updated_at(5i)]">\n<option selected="selected" value="00">00</option>\n</select>\n</div>),
-      datetime_select("post", "updated_at", :discard_year => true, :discard_month => true, :discard_day => true, :minute_step => 60)
-    )
-  end
-
-  def test_time_select_with_errors
-    assert_dom_equal(
-      %(<div class="field_with_errors"><input id="post_updated_at_1i" name="post[updated_at(1i)]" type="hidden" value="2004" />\n<input id="post_updated_at_2i" name="post[updated_at(2i)]" type="hidden" value="6" />\n<input id="post_updated_at_3i" name="post[updated_at(3i)]" type="hidden" value="15" />\n<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n<option selected="selected" value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n</select>\n : <select id="post_updated_at_5i" name="post[updated_at(5i)]">\n<option selected="selected" value="00">00</option>\n</select>\n</div>),
-      time_select("post", "updated_at", :minute_step => 60)
-    )
-  end
-
-  def test_hidden_field_does_not_render_errors
-    assert_dom_equal(
-      %(<input id="post_author_name" name="post[author_name]" type="hidden" value="" />),
-      hidden_field("post", "author_name")
-    )
-  end
-
-  def test_field_error_proc
-    old_proc = ActionView::Base.field_error_proc
-    ActionView::Base.field_error_proc = Proc.new do |html_tag, instance|
-      %(<div class=\"field_with_errors\">#{html_tag} <span class="error">#{[instance.error_message].join(', ')}</span></div>).html_safe
-    end
-
-    assert_dom_equal(
-      %(<div class="field_with_errors"><input id="post_author_name" name="post[author_name]" type="text" value="" /> <span class="error">can't be empty</span></div>),
-      text_field("post", "author_name")
-    )
-  ensure
-    ActionView::Base.field_error_proc = old_proc if old_proc
-  end
-
-end
diff --git a/actionpack/test/template/asset_tag_helper_test.rb b/actionpack/test/template/asset_tag_helper_test.rb
deleted file mode 100644
index 67f593c22f..0000000000
--- a/actionpack/test/template/asset_tag_helper_test.rb
+++ /dev/null
@@ -1,757 +0,0 @@
-require 'zlib'
-require 'abstract_unit'
-require 'active_support/ordered_options'
-
-class FakeController
-  attr_accessor :request
-
-  def config
-    @config ||= ActiveSupport::InheritableOptions.new(ActionController::Base.config)
-  end
-end
-
-class AssetTagHelperTest < ActionView::TestCase
-  tests ActionView::Helpers::AssetTagHelper
-
-  attr_reader :request
-
-  def setup
-    super
-
-    @controller = BasicController.new
-
-    @request = Class.new do
-      attr_accessor :script_name
-      def protocol() 'http://' end
-      def ssl?() false end
-      def host_with_port() 'localhost' end
-      def base_url() 'http://www.example.com' end
-    end.new
-
-    @controller.request = @request
-  end
-
-  def url_for(*args)
-    "http://www.example.com"
-  end
-
-  AssetPathToTag = {
-    %(asset_path("foo"))          => %(/foo),
-    %(asset_path("style.css"))    => %(/style.css),
-    %(asset_path("xmlhr.js"))     => %(/xmlhr.js),
-    %(asset_path("xml.png"))      => %(/xml.png),
-    %(asset_path("dir/xml.png"))  => %(/dir/xml.png),
-    %(asset_path("/dir/xml.png")) => %(/dir/xml.png),
-
-    %(asset_path("script.min"))       => %(/script.min),
-    %(asset_path("script.min.js"))    => %(/script.min.js),
-    %(asset_path("style.min"))        => %(/style.min),
-    %(asset_path("style.min.css"))    => %(/style.min.css),
-
-    %(asset_path("style", type: :stylesheet)) => %(/stylesheets/style.css),
-    %(asset_path("xmlhr", type: :javascript)) => %(/javascripts/xmlhr.js),
-    %(asset_path("xml.png", type: :image))    => %(/images/xml.png)
-  }
-
-  AutoDiscoveryToTag = {
-    %(auto_discovery_link_tag) => %(<link href="http://www.example.com" rel="alternate" title="RSS" type="application/rss+xml" />),
-    %(auto_discovery_link_tag(:rss)) => %(<link href="http://www.example.com" rel="alternate" title="RSS" type="application/rss+xml" />),
-    %(auto_discovery_link_tag(:atom)) => %(<link href="http://www.example.com" rel="alternate" title="ATOM" type="application/atom+xml" />),
-    %(auto_discovery_link_tag(:rss, :action => "feed")) => %(<link href="http://www.example.com" rel="alternate" title="RSS" type="application/rss+xml" />),
-    %(auto_discovery_link_tag(:rss, "http://localhost/feed")) => %(<link href="http://localhost/feed" rel="alternate" title="RSS" type="application/rss+xml" />),
-    %(auto_discovery_link_tag(:rss, "//localhost/feed")) => %(<link href="//localhost/feed" rel="alternate" title="RSS" type="application/rss+xml" />),
-    %(auto_discovery_link_tag(:rss, {:action => "feed"}, {:title => "My RSS"})) => %(<link href="http://www.example.com" rel="alternate" title="My RSS" type="application/rss+xml" />),
-    %(auto_discovery_link_tag(:rss, {}, {:title => "My RSS"})) => %(<link href="http://www.example.com" rel="alternate" title="My RSS" type="application/rss+xml" />),
-    %(auto_discovery_link_tag(nil, {}, {:type => "text/html"})) => %(<link href="http://www.example.com" rel="alternate" title="" type="text/html" />),
-    %(auto_discovery_link_tag(nil, {}, {:title => "No stream.. really", :type => "text/html"})) => %(<link href="http://www.example.com" rel="alternate" title="No stream.. really" type="text/html" />),
-    %(auto_discovery_link_tag(:rss, {}, {:title => "My RSS", :type => "text/html"})) => %(<link href="http://www.example.com" rel="alternate" title="My RSS" type="text/html" />),
-    %(auto_discovery_link_tag(:atom, {}, {:rel => "Not so alternate"})) => %(<link href="http://www.example.com" rel="Not so alternate" title="ATOM" type="application/atom+xml" />),
-  }
-
-  JavascriptPathToTag = {
-    %(javascript_path("xmlhr")) => %(/javascripts/xmlhr.js),
-    %(javascript_path("super/xmlhr")) => %(/javascripts/super/xmlhr.js),
-    %(javascript_path("/super/xmlhr.js")) => %(/super/xmlhr.js),
-    %(javascript_path("xmlhr.min")) => %(/javascripts/xmlhr.min.js),
-    %(javascript_path("xmlhr.min.js")) => %(/javascripts/xmlhr.min.js),
-
-    %(javascript_path("xmlhr.js?123")) => %(/javascripts/xmlhr.js?123),
-    %(javascript_path("xmlhr.js?body=1")) => %(/javascripts/xmlhr.js?body=1),
-    %(javascript_path("xmlhr.js#hash")) => %(/javascripts/xmlhr.js#hash),
-    %(javascript_path("xmlhr.js?123#hash")) => %(/javascripts/xmlhr.js?123#hash)
-  }
-
-  PathToJavascriptToTag = {
-    %(path_to_javascript("xmlhr")) => %(/javascripts/xmlhr.js),
-    %(path_to_javascript("super/xmlhr")) => %(/javascripts/super/xmlhr.js),
-    %(path_to_javascript("/super/xmlhr.js")) => %(/super/xmlhr.js)
-  }
-
-  JavascriptUrlToTag = {
-    %(javascript_url("xmlhr")) => %(http://www.example.com/javascripts/xmlhr.js),
-    %(javascript_url("super/xmlhr")) => %(http://www.example.com/javascripts/super/xmlhr.js),
-    %(javascript_url("/super/xmlhr.js")) => %(http://www.example.com/super/xmlhr.js)
-  }
-
-  UrlToJavascriptToTag = {
-    %(url_to_javascript("xmlhr")) => %(http://www.example.com/javascripts/xmlhr.js),
-    %(url_to_javascript("super/xmlhr")) => %(http://www.example.com/javascripts/super/xmlhr.js),
-    %(url_to_javascript("/super/xmlhr.js")) => %(http://www.example.com/super/xmlhr.js)
-  }
-
-  JavascriptIncludeToTag = {
-    %(javascript_include_tag("bank")) => %(<script src="/javascripts/bank.js" ></script>),
-    %(javascript_include_tag("bank.js")) => %(<script src="/javascripts/bank.js" ></script>),
-    %(javascript_include_tag("bank", :lang => "vbscript")) => %(<script lang="vbscript" src="/javascripts/bank.js" ></script>),
-
-    %(javascript_include_tag("http://example.com/all")) => %(<script src="http://example.com/all"></script>),
-    %(javascript_include_tag("http://example.com/all.js")) => %(<script src="http://example.com/all.js"></script>),
-    %(javascript_include_tag("//example.com/all.js")) => %(<script src="//example.com/all.js"></script>),
-  }
-
-  StylePathToTag = {
-    %(stylesheet_path("bank")) => %(/stylesheets/bank.css),
-    %(stylesheet_path("bank.css")) => %(/stylesheets/bank.css),
-    %(stylesheet_path('subdir/subdir')) => %(/stylesheets/subdir/subdir.css),
-    %(stylesheet_path('/subdir/subdir.css')) => %(/subdir/subdir.css),
-    %(stylesheet_path("style.min")) => %(/stylesheets/style.min.css),
-    %(stylesheet_path("style.min.css")) => %(/stylesheets/style.min.css)
-  }
-
-  PathToStyleToTag = {
-    %(path_to_stylesheet("style")) => %(/stylesheets/style.css),
-    %(path_to_stylesheet("style.css")) => %(/stylesheets/style.css),
-    %(path_to_stylesheet('dir/file')) => %(/stylesheets/dir/file.css),
-    %(path_to_stylesheet('/dir/file.rcss', :extname => false)) => %(/dir/file.rcss),
-    %(path_to_stylesheet('/dir/file', :extname => '.rcss')) => %(/dir/file.rcss)
-  }
-
-  StyleUrlToTag = {
-    %(stylesheet_url("bank")) => %(http://www.example.com/stylesheets/bank.css),
-    %(stylesheet_url("bank.css")) => %(http://www.example.com/stylesheets/bank.css),
-    %(stylesheet_url('subdir/subdir')) => %(http://www.example.com/stylesheets/subdir/subdir.css),
-    %(stylesheet_url('/subdir/subdir.css')) => %(http://www.example.com/subdir/subdir.css)
-  }
-
-  UrlToStyleToTag = {
-    %(url_to_stylesheet("style")) => %(http://www.example.com/stylesheets/style.css),
-    %(url_to_stylesheet("style.css")) => %(http://www.example.com/stylesheets/style.css),
-    %(url_to_stylesheet('dir/file')) => %(http://www.example.com/stylesheets/dir/file.css),
-    %(url_to_stylesheet('/dir/file.rcss', :extname => false)) => %(http://www.example.com/dir/file.rcss),
-    %(url_to_stylesheet('/dir/file', :extname => '.rcss')) => %(http://www.example.com/dir/file.rcss)
-  }
-
-  StyleLinkToTag = {
-    %(stylesheet_link_tag("bank")) => %(<link href="/stylesheets/bank.css" media="screen" rel="stylesheet" />),
-    %(stylesheet_link_tag("bank.css")) => %(<link href="/stylesheets/bank.css" media="screen" rel="stylesheet" />),
-    %(stylesheet_link_tag("/elsewhere/file")) => %(<link href="/elsewhere/file.css" media="screen" rel="stylesheet" />),
-    %(stylesheet_link_tag("subdir/subdir")) => %(<link href="/stylesheets/subdir/subdir.css" media="screen" rel="stylesheet" />),
-    %(stylesheet_link_tag("bank", :media => "all")) => %(<link href="/stylesheets/bank.css" media="all" rel="stylesheet" />),
-
-    %(stylesheet_link_tag("http://www.example.com/styles/style")) => %(<link href="http://www.example.com/styles/style" media="screen" rel="stylesheet" />),
-    %(stylesheet_link_tag("http://www.example.com/styles/style.css")) => %(<link href="http://www.example.com/styles/style.css" media="screen" rel="stylesheet" />),
-    %(stylesheet_link_tag("//www.example.com/styles/style.css")) => %(<link href="//www.example.com/styles/style.css" media="screen" rel="stylesheet" />),
-  }
-
-  ImagePathToTag = {
-    %(image_path("xml"))          => %(/images/xml),
-    %(image_path("xml.png"))      => %(/images/xml.png),
-    %(image_path("dir/xml.png"))  => %(/images/dir/xml.png),
-    %(image_path("/dir/xml.png")) => %(/dir/xml.png)
-  }
-
-  PathToImageToTag = {
-    %(path_to_image("xml"))          => %(/images/xml),
-    %(path_to_image("xml.png"))      => %(/images/xml.png),
-    %(path_to_image("dir/xml.png"))  => %(/images/dir/xml.png),
-    %(path_to_image("/dir/xml.png")) => %(/dir/xml.png)
-  }
-
-  ImageUrlToTag = {
-    %(image_url("xml"))          => %(http://www.example.com/images/xml),
-    %(image_url("xml.png"))      => %(http://www.example.com/images/xml.png),
-    %(image_url("dir/xml.png"))  => %(http://www.example.com/images/dir/xml.png),
-    %(image_url("/dir/xml.png")) => %(http://www.example.com/dir/xml.png)
-  }
-
-  UrlToImageToTag = {
-    %(url_to_image("xml"))          => %(http://www.example.com/images/xml),
-    %(url_to_image("xml.png"))      => %(http://www.example.com/images/xml.png),
-    %(url_to_image("dir/xml.png"))  => %(http://www.example.com/images/dir/xml.png),
-    %(url_to_image("/dir/xml.png")) => %(http://www.example.com/dir/xml.png)
-  }
-
-  ImageLinkToTag = {
-    %(image_tag("xml.png")) => %(<img alt="Xml" src="/images/xml.png" />),
-    %(image_tag("rss.gif", :alt => "rss syndication")) => %(<img alt="rss syndication" src="/images/rss.gif" />),
-    %(image_tag("gold.png", :size => "20")) => %(<img alt="Gold" height="20" src="/images/gold.png" width="20" />),
-    %(image_tag("gold.png", :size => "45x70")) => %(<img alt="Gold" height="70" src="/images/gold.png" width="45" />),
-    %(image_tag("gold.png", "size" => "45x70")) => %(<img alt="Gold" height="70" src="/images/gold.png" width="45" />),
-    %(image_tag("error.png", "size" => "45 x 70")) => %(<img alt="Error" src="/images/error.png" />),
-    %(image_tag("error.png", "size" => "x")) => %(<img alt="Error" src="/images/error.png" />),
-    %(image_tag("google.com.png")) => %(<img alt="Google.com" src="/images/google.com.png" />),
-    %(image_tag("slash..png")) => %(<img alt="Slash." src="/images/slash..png" />),
-    %(image_tag(".pdf.png")) => %(<img alt=".pdf" src="/images/.pdf.png" />),
-    %(image_tag("http://www.rubyonrails.com/images/rails.png")) => %(<img alt="Rails" src="http://www.rubyonrails.com/images/rails.png" />),
-    %(image_tag("//www.rubyonrails.com/images/rails.png")) => %(<img alt="Rails" src="//www.rubyonrails.com/images/rails.png" />),
-    %(image_tag("mouse.png", :alt => nil)) => %(<img src="/images/mouse.png" />),
-    %(image_tag("data:image/gif;base64,R0lGODlhAQABAID/AMDAwAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==", :alt => nil)) => %(<img src="data:image/gif;base64,R0lGODlhAQABAID/AMDAwAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==" />),
-    %(image_tag("")) => %(<img src="" />)
-  }
-
-  FaviconLinkToTag = {
-    %(favicon_link_tag) => %(<link href="/images/favicon.ico" rel="shortcut icon" type="image/vnd.microsoft.icon" />),
-    %(favicon_link_tag 'favicon.ico') => %(<link href="/images/favicon.ico" rel="shortcut icon" type="image/vnd.microsoft.icon" />),
-    %(favicon_link_tag 'favicon.ico', :rel => 'foo') => %(<link href="/images/favicon.ico" rel="foo" type="image/vnd.microsoft.icon" />),
-    %(favicon_link_tag 'favicon.ico', :rel => 'foo', :type => 'bar') => %(<link href="/images/favicon.ico" rel="foo" type="bar" />),
-    %(favicon_link_tag 'mb-icon.png', :rel => 'apple-touch-icon', :type => 'image/png') => %(<link href="/images/mb-icon.png" rel="apple-touch-icon" type="image/png" />)
-  }
-
-  VideoPathToTag = {
-    %(video_path("xml"))          => %(/videos/xml),
-    %(video_path("xml.ogg"))      => %(/videos/xml.ogg),
-    %(video_path("dir/xml.ogg"))  => %(/videos/dir/xml.ogg),
-    %(video_path("/dir/xml.ogg")) => %(/dir/xml.ogg)
-  }
-
-  PathToVideoToTag = {
-    %(path_to_video("xml"))          => %(/videos/xml),
-    %(path_to_video("xml.ogg"))      => %(/videos/xml.ogg),
-    %(path_to_video("dir/xml.ogg"))  => %(/videos/dir/xml.ogg),
-    %(path_to_video("/dir/xml.ogg")) => %(/dir/xml.ogg)
-  }
-
-  VideoUrlToTag = {
-    %(video_url("xml"))          => %(http://www.example.com/videos/xml),
-    %(video_url("xml.ogg"))      => %(http://www.example.com/videos/xml.ogg),
-    %(video_url("dir/xml.ogg"))  => %(http://www.example.com/videos/dir/xml.ogg),
-    %(video_url("/dir/xml.ogg")) => %(http://www.example.com/dir/xml.ogg)
-  }
-
-  UrlToVideoToTag = {
-    %(url_to_video("xml"))          => %(http://www.example.com/videos/xml),
-    %(url_to_video("xml.ogg"))      => %(http://www.example.com/videos/xml.ogg),
-    %(url_to_video("dir/xml.ogg"))  => %(http://www.example.com/videos/dir/xml.ogg),
-    %(url_to_video("/dir/xml.ogg")) => %(http://www.example.com/dir/xml.ogg)
-  }
-
-  VideoLinkToTag = {
-    %(video_tag("xml.ogg")) => %(<video src="/videos/xml.ogg"></video>),
-    %(video_tag("rss.m4v", :autoplay => true, :controls => true)) => %(<video autoplay="autoplay" controls="controls" src="/videos/rss.m4v"></video>),
-    %(video_tag("rss.m4v", :autobuffer => true)) => %(<video autobuffer="autobuffer" src="/videos/rss.m4v"></video>),
-    %(video_tag("gold.m4v", :size => "160x120")) => %(<video height="120" src="/videos/gold.m4v" width="160"></video>),
-    %(video_tag("gold.m4v", "size" => "320x240")) => %(<video height="240" src="/videos/gold.m4v" width="320"></video>),
-    %(video_tag("trailer.ogg", :poster => "screenshot.png")) => %(<video poster="/images/screenshot.png" src="/videos/trailer.ogg"></video>),
-    %(video_tag("error.avi", "size" => "100")) => %(<video src="/videos/error.avi"></video>),
-    %(video_tag("error.avi", "size" => "100 x 100")) => %(<video src="/videos/error.avi"></video>),
-    %(video_tag("error.avi", "size" => "x")) => %(<video src="/videos/error.avi"></video>),
-    %(video_tag("http://media.rubyonrails.org/video/rails_blog_2.mov")) => %(<video src="http://media.rubyonrails.org/video/rails_blog_2.mov"></video>),
-    %(video_tag("//media.rubyonrails.org/video/rails_blog_2.mov")) => %(<video src="//media.rubyonrails.org/video/rails_blog_2.mov"></video>),
-    %(video_tag("multiple.ogg", "multiple.avi")) => %(<video><source src="/videos/multiple.ogg" /><source src="/videos/multiple.avi" /></video>),
-    %(video_tag(["multiple.ogg", "multiple.avi"])) => %(<video><source src="/videos/multiple.ogg" /><source src="/videos/multiple.avi" /></video>),
-    %(video_tag(["multiple.ogg", "multiple.avi"], :size => "160x120", :controls => true)) => %(<video controls="controls" height="120" width="160"><source src="/videos/multiple.ogg" /><source src="/videos/multiple.avi" /></video>)
-  }
-
-  AudioPathToTag = {
-    %(audio_path("xml"))          => %(/audios/xml),
-    %(audio_path("xml.wav"))      => %(/audios/xml.wav),
-    %(audio_path("dir/xml.wav"))  => %(/audios/dir/xml.wav),
-    %(audio_path("/dir/xml.wav")) => %(/dir/xml.wav)
-  }
-
-  PathToAudioToTag = {
-    %(path_to_audio("xml"))          => %(/audios/xml),
-    %(path_to_audio("xml.wav"))      => %(/audios/xml.wav),
-    %(path_to_audio("dir/xml.wav"))  => %(/audios/dir/xml.wav),
-    %(path_to_audio("/dir/xml.wav")) => %(/dir/xml.wav)
-  }
-
-  AudioUrlToTag = {
-    %(audio_url("xml"))          => %(http://www.example.com/audios/xml),
-    %(audio_url("xml.wav"))      => %(http://www.example.com/audios/xml.wav),
-    %(audio_url("dir/xml.wav"))  => %(http://www.example.com/audios/dir/xml.wav),
-    %(audio_url("/dir/xml.wav")) => %(http://www.example.com/dir/xml.wav)
-  }
-
-  UrlToAudioToTag = {
-    %(url_to_audio("xml"))          => %(http://www.example.com/audios/xml),
-    %(url_to_audio("xml.wav"))      => %(http://www.example.com/audios/xml.wav),
-    %(url_to_audio("dir/xml.wav"))  => %(http://www.example.com/audios/dir/xml.wav),
-    %(url_to_audio("/dir/xml.wav")) => %(http://www.example.com/dir/xml.wav)
-  }
-
-  AudioLinkToTag = {
-    %(audio_tag("xml.wav")) => %(<audio src="/audios/xml.wav"></audio>),
-    %(audio_tag("rss.wav", :autoplay => true, :controls => true)) => %(<audio autoplay="autoplay" controls="controls" src="/audios/rss.wav"></audio>),
-    %(audio_tag("http://media.rubyonrails.org/audio/rails_blog_2.mov")) => %(<audio src="http://media.rubyonrails.org/audio/rails_blog_2.mov"></audio>),
-    %(audio_tag("//media.rubyonrails.org/audio/rails_blog_2.mov")) => %(<audio src="//media.rubyonrails.org/audio/rails_blog_2.mov"></audio>),
-    %(audio_tag("audio.mp3", "audio.ogg")) => %(<audio><source src="/audios/audio.mp3" /><source src="/audios/audio.ogg" /></audio>),
-    %(audio_tag(["audio.mp3", "audio.ogg"])) => %(<audio><source src="/audios/audio.mp3" /><source src="/audios/audio.ogg" /></audio>),
-    %(audio_tag(["audio.mp3", "audio.ogg"], :autobuffer => true, :controls => true)) => %(<audio autobuffer="autobuffer" controls="controls"><source src="/audios/audio.mp3" /><source src="/audios/audio.ogg" /></audio>)
-  }
-
-  FontPathToTag = {
-    %(font_path("font.eot")) => %(/fonts/font.eot),
-    %(font_path("font.eot#iefix")) => %(/fonts/font.eot#iefix),
-    %(font_path("font.woff")) => %(/fonts/font.woff),
-    %(font_path("font.ttf")) => %(/fonts/font.ttf),
-    %(font_path("font.ttf?123")) => %(/fonts/font.ttf?123)
-  }
-
-  def test_autodiscovery_link_tag_deprecated_types
-    result = nil
-    assert_deprecated do
-      result = auto_discovery_link_tag(:xml)
-    end
-
-    expected = %(<link href="http://www.example.com" rel="alternate" title="XML" type="application/xml" />)
-    assert_equal expected, result
-  end
-
-  def test_asset_path_tag
-    AssetPathToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_compute_asset_public_path
-    assert_equal "/robots.txt", compute_asset_path("robots.txt")
-    assert_equal "/robots.txt", compute_asset_path("/robots.txt")
-    assert_equal "/javascripts/foo.js", compute_asset_path("foo.js", :type => :javascript)
-    assert_equal "/javascripts/foo.js", compute_asset_path("/foo.js", :type => :javascript)
-    assert_equal "/stylesheets/foo.css", compute_asset_path("foo.css", :type => :stylesheet)
-  end
-
-  def test_auto_discovery_link_tag
-    AutoDiscoveryToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_javascript_path
-    JavascriptPathToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_path_to_javascript_alias_for_javascript_path
-    PathToJavascriptToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_javascript_url
-    JavascriptUrlToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_url_to_javascript_alias_for_javascript_url
-    UrlToJavascriptToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_javascript_include_tag
-    JavascriptIncludeToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_javascript_include_tag_with_missing_source
-    assert_nothing_raised {
-      javascript_include_tag('missing_security_guard')
-    }
-
-    assert_nothing_raised {
-      javascript_include_tag('http://example.com/css/missing_security_guard')
-    }
-  end
-
-  def test_javascript_include_tag_is_html_safe
-    assert javascript_include_tag("prototype").html_safe?
-  end
-
-  def test_javascript_include_tag_relative_protocol
-    @controller.config.asset_host = "assets.example.com"
-    assert_dom_equal %(<script src="//assets.example.com/javascripts/prototype.js"></script>), javascript_include_tag('prototype', protocol: :relative)
-  end
-
-  def test_javascript_include_tag_default_protocol
-    @controller.config.asset_host = "assets.example.com"
-    @controller.config.default_asset_host_protocol = :relative
-    assert_dom_equal %(<script src="//assets.example.com/javascripts/prototype.js"></script>), javascript_include_tag('prototype')
-  end
-
-  def test_stylesheet_path
-    StylePathToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_path_to_stylesheet_alias_for_stylesheet_path
-    PathToStyleToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_stylesheet_url
-    StyleUrlToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_url_to_stylesheet_alias_for_stylesheet_url
-    UrlToStyleToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_stylesheet_link_tag
-    StyleLinkToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_stylesheet_link_tag_with_missing_source
-    assert_nothing_raised {
-      stylesheet_link_tag('missing_security_guard')
-    }
-
-    assert_nothing_raised {
-      stylesheet_link_tag('http://example.com/css/missing_security_guard')
-    }
-  end
-
-  def test_stylesheet_link_tag_is_html_safe
-    assert stylesheet_link_tag('dir/file').html_safe?
-    assert stylesheet_link_tag('dir/other/file', 'dir/file2').html_safe?
-  end
-
-  def test_stylesheet_link_tag_escapes_options
-    assert_dom_equal %(<link href="/file.css" media="&lt;script&gt;" rel="stylesheet" />), stylesheet_link_tag('/file', :media => '<script>')
-  end
-
-  def test_stylesheet_link_tag_should_not_output_the_same_asset_twice
-    assert_dom_equal %(<link href="/stylesheets/wellington.css" media="screen" rel="stylesheet" />\n<link href="/stylesheets/amsterdam.css" media="screen" rel="stylesheet" />), stylesheet_link_tag('wellington', 'wellington', 'amsterdam')
-  end
-
-  def test_stylesheet_link_tag_with_relative_protocol
-    @controller.config.asset_host = "assets.example.com"
-    assert_dom_equal %(<link href="//assets.example.com/stylesheets/wellington.css" media="screen" rel="stylesheet" />), stylesheet_link_tag('wellington', protocol: :relative)
-  end
-
-  def test_stylesheet_link_tag_with_default_protocol
-    @controller.config.asset_host = "assets.example.com"
-    @controller.config.default_asset_host_protocol = :relative
-    assert_dom_equal %(<link href="//assets.example.com/stylesheets/wellington.css" media="screen" rel="stylesheet" />), stylesheet_link_tag('wellington')
-  end
-
-  def test_image_path
-    ImagePathToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_path_to_image_alias_for_image_path
-    PathToImageToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_image_url
-    ImageUrlToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_url_to_image_alias_for_image_url
-    UrlToImageToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_image_alt
-    [nil, '/', '/foo/bar/', 'foo/bar/'].each do |prefix|
-      assert_equal 'Rails', image_alt("#{prefix}rails.png")
-      assert_equal 'Rails', image_alt("#{prefix}rails-9c0a079bdd7701d7e729bd956823d153.png")
-      assert_equal 'Long file name with hyphens', image_alt("#{prefix}long-file-name-with-hyphens.png") 
-      assert_equal 'Long file name with underscores', image_alt("#{prefix}long_file_name_with_underscores.png")  
-    end
-  end
-
-  def test_image_tag
-    ImageLinkToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_image_tag_does_not_modify_options
-    options = {:size => '16x10'}
-    image_tag('icon', options)
-    assert_equal({:size => '16x10'}, options)
-  end
-
-  def test_favicon_link_tag
-    FaviconLinkToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_video_path
-    VideoPathToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_path_to_video_alias_for_video_path
-    PathToVideoToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_video_url
-    VideoUrlToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_url_to_video_alias_for_video_url
-    UrlToVideoToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_video_tag
-    VideoLinkToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_audio_path
-    AudioPathToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_path_to_audio_alias_for_audio_path
-    PathToAudioToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_audio_url
-    AudioUrlToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_url_to_audio_alias_for_audio_url
-    UrlToAudioToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_audio_tag
-    AudioLinkToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_font_path
-    FontPathToTag.each { |method, tag| assert_dom_equal(tag, eval(method)) }
-  end
-
-  def test_video_audio_tag_does_not_modify_options
-    options = {:autoplay => true}
-    video_tag('video', options)
-    assert_equal({:autoplay => true}, options)
-    audio_tag('audio', options)
-    assert_equal({:autoplay => true}, options)
-  end
-
-  def test_image_tag_interpreting_email_cid_correctly
-    # An inline image has no need for an alt tag to be automatically generated from the cid:
-    assert_equal '<img src="cid:thi%25%25sis@acontentid" />', image_tag("cid:thi%25%25sis@acontentid")
-  end
-
-  def test_image_tag_interpreting_email_adding_optional_alt_tag
-    assert_equal '<img alt="Image" src="cid:thi%25%25sis@acontentid" />', image_tag("cid:thi%25%25sis@acontentid", :alt => "Image")
-  end
-
-  def test_should_not_modify_source_string
-    source = '/images/rails.png'
-    copy = source.dup
-    image_tag(source)
-    assert_equal copy, source
-  end
-
-  def test_image_path_with_asset_host_proc_returning_nil
-    @controller.config.asset_host = Proc.new do |source|
-      unless source.end_with?("tiff")
-        "cdn.example.com"
-      end
-    end
-
-    assert_equal "/images/file.tiff", image_path("file.tiff")
-    assert_equal "http://cdn.example.com/images/file.png", image_path("file.png")
-  end
-
-  def test_caching_image_path_with_caching_and_proc_asset_host_using_request
-    @controller.config.asset_host = Proc.new do |source, request|
-      if request.ssl?
-        "#{request.protocol}#{request.host_with_port}"
-      else
-        "#{request.protocol}assets#{source.length}.example.com"
-      end
-    end
-
-    @controller.request.stubs(:ssl?).returns(false)
-    assert_equal "http://assets15.example.com/images/xml.png", image_path("xml.png")
-
-    @controller.request.stubs(:ssl?).returns(true)
-    assert_equal "http://localhost/images/xml.png", image_path("xml.png")
-  end
-end
-
-class AssetTagHelperNonVhostTest < ActionView::TestCase
-  tests ActionView::Helpers::AssetTagHelper
-
-  attr_reader :request
-
-  def setup
-    super
-    @controller = BasicController.new
-    @controller.config.relative_url_root = "/collaboration/hieraki"
-
-    @request = Struct.new(:protocol, :base_url).new("gopher://", "gopher://www.example.com")
-    @controller.request = @request
-  end
-
-  def url_for(options)
-    "http://www.example.com/collaboration/hieraki"
-  end
-
-  def test_should_compute_proper_path
-    assert_dom_equal(%(<link href="http://www.example.com/collaboration/hieraki" rel="alternate" title="RSS" type="application/rss+xml" />), auto_discovery_link_tag)
-    assert_dom_equal(%(/collaboration/hieraki/javascripts/xmlhr.js), javascript_path("xmlhr"))
-    assert_dom_equal(%(/collaboration/hieraki/stylesheets/style.css), stylesheet_path("style"))
-    assert_dom_equal(%(/collaboration/hieraki/images/xml.png), image_path("xml.png"))
-  end
-
-  def test_should_return_nothing_if_asset_host_isnt_configured
-    assert_equal nil, compute_asset_host("foo")
-  end
-
-  def test_should_current_request_host_is_always_returned_for_request
-    assert_equal "gopher://www.example.com", compute_asset_host("foo", :protocol => :request)
-  end
-
-  def test_should_ignore_relative_root_path_on_complete_url
-    assert_dom_equal(%(http://www.example.com/images/xml.png), image_path("http://www.example.com/images/xml.png"))
-  end
-
-  def test_should_return_simple_string_asset_host
-    @controller.config.asset_host = "assets.example.com"
-    assert_equal "gopher://assets.example.com", compute_asset_host("foo")
-  end
-
-  def test_should_return_relative_asset_host
-    @controller.config.asset_host = "assets.example.com"
-    assert_equal "//assets.example.com", compute_asset_host("foo", :protocol => :relative)
-  end
-
-  def test_should_return_custom_protocol_asset_host
-    @controller.config.asset_host = "assets.example.com"
-    assert_equal "ftp://assets.example.com", compute_asset_host("foo", :protocol => "ftp")
-  end
-
-  def test_should_compute_proper_path_with_asset_host
-    @controller.config.asset_host = "assets.example.com"
-    assert_dom_equal(%(<link href="http://www.example.com/collaboration/hieraki" rel="alternate" title="RSS" type="application/rss+xml" />), auto_discovery_link_tag)
-    assert_dom_equal(%(gopher://assets.example.com/collaboration/hieraki/javascripts/xmlhr.js), javascript_path("xmlhr"))
-    assert_dom_equal(%(gopher://assets.example.com/collaboration/hieraki/stylesheets/style.css), stylesheet_path("style"))
-    assert_dom_equal(%(gopher://assets.example.com/collaboration/hieraki/images/xml.png), image_path("xml.png"))
-  end
-
-  def test_should_compute_proper_path_with_asset_host_and_default_protocol
-    @controller.config.asset_host = "assets.example.com"
-    @controller.config.default_asset_host_protocol = :request
-    assert_dom_equal(%(gopher://assets.example.com/collaboration/hieraki/javascripts/xmlhr.js), javascript_path("xmlhr"))
-    assert_dom_equal(%(gopher://assets.example.com/collaboration/hieraki/stylesheets/style.css), stylesheet_path("style"))
-    assert_dom_equal(%(gopher://assets.example.com/collaboration/hieraki/images/xml.png), image_path("xml.png"))
-  end
-
-  def test_should_compute_proper_url_with_asset_host
-    @controller.config.asset_host = "assets.example.com"
-    assert_dom_equal(%(<link href="http://www.example.com/collaboration/hieraki" rel="alternate" title="RSS" type="application/rss+xml" />), auto_discovery_link_tag)
-    assert_dom_equal(%(gopher://assets.example.com/collaboration/hieraki/javascripts/xmlhr.js), javascript_url("xmlhr"))
-    assert_dom_equal(%(gopher://assets.example.com/collaboration/hieraki/stylesheets/style.css), stylesheet_url("style"))
-    assert_dom_equal(%(gopher://assets.example.com/collaboration/hieraki/images/xml.png), image_url("xml.png"))
-  end
-
-  def test_should_compute_proper_url_with_asset_host_and_default_protocol
-    @controller.config.asset_host = "assets.example.com"
-    @controller.config.default_asset_host_protocol = :request
-    assert_dom_equal(%(gopher://assets.example.com/collaboration/hieraki/javascripts/xmlhr.js), javascript_url("xmlhr"))
-    assert_dom_equal(%(gopher://assets.example.com/collaboration/hieraki/stylesheets/style.css), stylesheet_url("style"))
-    assert_dom_equal(%(gopher://assets.example.com/collaboration/hieraki/images/xml.png), image_url("xml.png"))
-  end
-
-  def test_should_return_asset_host_with_protocol
-    @controller.config.asset_host = "http://assets.example.com"
-    assert_equal "http://assets.example.com", compute_asset_host("foo")
-  end
-
-  def test_should_ignore_asset_host_on_complete_url
-    @controller.config.asset_host = "http://assets.example.com"
-    assert_dom_equal(%(<link href="http://bar.example.com/stylesheets/style.css" media="screen" rel="stylesheet" />), stylesheet_link_tag("http://bar.example.com/stylesheets/style.css"))
-  end
-
-  def test_should_ignore_asset_host_on_scheme_relative_url
-    @controller.config.asset_host = "http://assets.example.com"
-    assert_dom_equal(%(<link href="//bar.example.com/stylesheets/style.css" media="screen" rel="stylesheet" />), stylesheet_link_tag("//bar.example.com/stylesheets/style.css"))
-  end
-
-  def test_should_wildcard_asset_host
-    @controller.config.asset_host = 'http://a%d.example.com'
-    assert_match(%r(http://a[0123].example.com), compute_asset_host("foo"))
-  end
-
-  def test_should_wildcard_asset_host_between_zero_and_four
-    @controller.config.asset_host = 'http://a%d.example.com'
-    assert_match(%r(http://a[0123].example.com/collaboration/hieraki/images/xml.png), image_path('xml.png'))
-    assert_match(%r(http://a[0123].example.com/collaboration/hieraki/images/xml.png), image_url('xml.png'))
-  end
-
-  def test_asset_host_without_protocol_should_be_protocol_relative
-    @controller.config.asset_host = 'a.example.com'
-    assert_equal 'gopher://a.example.com/collaboration/hieraki/images/xml.png', image_path('xml.png')
-    assert_equal 'gopher://a.example.com/collaboration/hieraki/images/xml.png', image_url('xml.png')
-  end
-
-  def test_asset_host_without_protocol_should_be_protocol_relative_even_if_path_present
-    @controller.config.asset_host = 'a.example.com/files/go/here'
-    assert_equal 'gopher://a.example.com/files/go/here/collaboration/hieraki/images/xml.png', image_path('xml.png')
-    assert_equal 'gopher://a.example.com/files/go/here/collaboration/hieraki/images/xml.png', image_url('xml.png')
-  end
-
-  def test_assert_css_and_js_of_the_same_name_return_correct_extension
-    assert_dom_equal(%(/collaboration/hieraki/javascripts/foo.js), javascript_path("foo"))
-    assert_dom_equal(%(/collaboration/hieraki/stylesheets/foo.css), stylesheet_path("foo"))
-  end
-end
-
-class AssetUrlHelperControllerTest < ActionView::TestCase
-  tests ActionView::Helpers::AssetUrlHelper
-
-  def setup
-    super
-
-    @controller = BasicController.new
-    @controller.extend ActionView::Helpers::AssetUrlHelper
-
-    @request = Class.new do
-      attr_accessor :script_name
-      def protocol() 'http://' end
-      def ssl?() false end
-      def host_with_port() 'www.example.com' end
-      def base_url() 'http://www.example.com' end
-    end.new
-
-    @controller.request = @request
-  end
-
-  def test_asset_path
-    assert_equal "/foo", @controller.asset_path("foo")
-  end
-
-  def test_asset_url
-    assert_equal "http://www.example.com/foo", @controller.asset_url("foo")
-  end
-end
-
-class AssetUrlHelperEmptyModuleTest < ActionView::TestCase
-  tests ActionView::Helpers::AssetUrlHelper
-
-  def setup
-    super
-
-    @module = Module.new
-    @module.extend ActionView::Helpers::AssetUrlHelper
-  end
-
-  def test_asset_path
-    assert_equal "/foo", @module.asset_path("foo")
-  end
-
-  def test_asset_url
-    assert_equal "/foo", @module.asset_url("foo")
-  end
-
-  def test_asset_url_with_request
-    @module.instance_eval do
-      def request
-        Struct.new(:base_url, :script_name).new("http://www.example.com", nil)
-      end
-    end
-
-    assert @module.request
-    assert_equal "http://www.example.com/foo", @module.asset_url("foo")
-  end
-
-  def test_asset_url_with_config_asset_host
-    @module.instance_eval do
-      def config
-        Struct.new(:asset_host).new("http://www.example.com")
-      end
-    end
-
-    assert @module.config.asset_host
-    assert_equal "http://www.example.com/foo", @module.asset_url("foo")
-  end
-end
diff --git a/actionpack/test/template/atom_feed_helper_test.rb b/actionpack/test/template/atom_feed_helper_test.rb
deleted file mode 100644
index 63b5ac0fab..0000000000
--- a/actionpack/test/template/atom_feed_helper_test.rb
+++ /dev/null
@@ -1,349 +0,0 @@
-require 'abstract_unit'
-
-class Scroll < Struct.new(:id, :to_param, :title, :body, :updated_at, :created_at)
-  extend ActiveModel::Naming
-  include ActiveModel::Conversion
-
-  def persisted?
-    false
-  end
-end
-
-class ScrollsController < ActionController::Base
-  FEEDS = {}
-  FEEDS["defaults"] = <<-EOT
-        atom_feed(:schema_date => '2008') do |feed|
-          feed.title("My great blog!")
-          feed.updated((@scrolls.first.created_at))
-
-          @scrolls.each do |scroll|
-            feed.entry(scroll) do |entry|
-              entry.title(scroll.title)
-              entry.content(scroll.body, :type => 'html')
-
-              entry.author do |author|
-                author.name("DHH")
-              end
-            end
-          end
-        end
-    EOT
-    FEEDS["entry_options"] = <<-EOT
-        atom_feed do |feed|
-          feed.title("My great blog!")
-          feed.updated((@scrolls.first.created_at))
-
-          @scrolls.each do |scroll|
-            feed.entry(scroll, :url => "/otherstuff/" + scroll.to_param.to_s, :updated => Time.utc(2007, 1, scroll.id)) do |entry|
-              entry.title(scroll.title)
-              entry.content(scroll.body, :type => 'html')
-
-              entry.author do |author|
-                author.name("DHH")
-              end
-            end
-          end
-        end
-    EOT
-    FEEDS["entry_type_options"] = <<-EOT
-        atom_feed(:schema_date => '2008') do |feed|
-          feed.title("My great blog!")
-          feed.updated((@scrolls.first.created_at))
-
-          @scrolls.each do |scroll|
-            feed.entry(scroll, :type => 'text/xml') do |entry|
-              entry.title(scroll.title)
-              entry.content(scroll.body, :type => 'html')
-
-              entry.author do |author|
-                author.name("DHH")
-              end
-            end
-          end
-        end
-    EOT
-    FEEDS["xml_block"] = <<-EOT
-        atom_feed do |feed|
-          feed.title("My great blog!")
-          feed.updated((@scrolls.first.created_at))
-
-          feed.author do |author|
-            author.name("DHH")
-          end
-
-          @scrolls.each do |scroll|
-            feed.entry(scroll, :url => "/otherstuff/" + scroll.to_param.to_s, :updated => Time.utc(2007, 1, scroll.id)) do |entry|
-              entry.title(scroll.title)
-              entry.content(scroll.body, :type => 'html')
-            end
-          end
-        end
-    EOT
-    FEEDS["feed_with_atomPub_namespace"] = <<-EOT
-        atom_feed({'xmlns:app' => 'http://www.w3.org/2007/app',
-                 'xmlns:openSearch' => 'http://a9.com/-/spec/opensearch/1.1/'}) do |feed|
-          feed.title("My great blog!")
-          feed.updated((@scrolls.first.created_at))
-
-          @scrolls.each do |scroll|
-            feed.entry(scroll) do |entry|
-              entry.title(scroll.title)
-              entry.content(scroll.body, :type => 'html')
-              entry.tag!('app:edited', Time.now)
-
-              entry.author do |author|
-                author.name("DHH")
-              end
-            end
-          end
-        end
-    EOT
-    FEEDS["feed_with_overridden_ids"] = <<-EOT
-        atom_feed({:id => 'tag:test.rubyonrails.org,2008:test/'}) do |feed|
-          feed.title("My great blog!")
-          feed.updated((@scrolls.first.created_at))
-
-          @scrolls.each do |scroll|
-            feed.entry(scroll, :id => "tag:test.rubyonrails.org,2008:"+scroll.id.to_s) do |entry|
-              entry.title(scroll.title)
-              entry.content(scroll.body, :type => 'html')
-              entry.tag!('app:edited', Time.now)
-
-              entry.author do |author|
-                author.name("DHH")
-              end
-            end
-          end
-        end
-    EOT
-  FEEDS["feed_with_xml_processing_instructions"] = <<-EOT
-        atom_feed(:schema_date => '2008',
-          :instruct => {'xml-stylesheet' => { :href=> 't.css', :type => 'text/css' }}) do |feed|
-          feed.title("My great blog!")
-          feed.updated((@scrolls.first.created_at))
-
-          @scrolls.each do |scroll|
-            feed.entry(scroll) do |entry|
-              entry.title(scroll.title)
-              entry.content(scroll.body, :type => 'html')
-
-              entry.author do |author|
-                author.name("DHH")
-              end
-            end
-          end
-        end
-    EOT
-  FEEDS["feed_with_xml_processing_instructions_duplicate_targets"] = <<-EOT
-        atom_feed(:schema_date => '2008',
-          :instruct => {'target1' => [{ :a => '1', :b => '2' }, { :c => '3', :d => '4' }]}) do |feed|
-          feed.title("My great blog!")
-          feed.updated((@scrolls.first.created_at))
-
-          @scrolls.each do |scroll|
-            feed.entry(scroll) do |entry|
-              entry.title(scroll.title)
-              entry.content(scroll.body, :type => 'html')
-
-              entry.author do |author|
-                author.name("DHH")
-              end
-            end
-          end
-        end
-    EOT
-    FEEDS["feed_with_xhtml_content"] = <<-'EOT'
-        atom_feed do |feed|
-          feed.title("My great blog!")
-          feed.updated((@scrolls.first.created_at))
-
-          @scrolls.each do |scroll|
-            feed.entry(scroll) do |entry|
-              entry.title(scroll.title)
-              entry.summary(:type => 'xhtml') do |xhtml|
-                xhtml.p "before #{scroll.id}"
-                xhtml.p {xhtml << scroll.body}
-                xhtml.p "after #{scroll.id}"
-              end
-              entry.tag!('app:edited', Time.now)
-
-              entry.author do |author|
-                author.name("DHH")
-              end
-            end
-          end
-        end
-    EOT
-    FEEDS["provide_builder"] = <<-'EOT'
-          # we pass in the new_xml to the helper so it doesn't
-          # call anything on the original builder
-          new_xml = Builder::XmlMarkup.new(:target=>'')
-          atom_feed(:xml => new_xml) do |feed|
-            feed.title("My great blog!")
-            feed.updated((@scrolls.first.created_at))
-
-            @scrolls.each do |scroll|
-              feed.entry(scroll) do |entry|
-                entry.title(scroll.title)
-                entry.content(scroll.body, :type => 'html')
-
-                entry.author do |author|
-                  author.name("DHH")
-                end
-              end
-            end
-          end
-    EOT
-  def index
-    @scrolls = [
-      Scroll.new(1, "1", "Hello One", "Something <i>COOL!</i>", Time.utc(2007, 12, 12, 15), Time.utc(2007, 12, 12, 15)),
-      Scroll.new(2, "2", "Hello Two", "Something Boring", Time.utc(2007, 12, 12, 15)),
-    ]
-
-    render :inline => FEEDS[params[:id]], :type => :builder
-  end
-end
-
-class AtomFeedTest < ActionController::TestCase
-  tests ScrollsController
-
-  def setup
-    super
-    @request.host = "www.nextangle.com"
-  end
-
-  def test_feed_should_use_default_language_if_none_is_given
-    with_restful_routing(:scrolls) do
-      get :index, :id => "defaults"
-      assert_match(%r{xml:lang="en-US"}, @response.body)
-    end
-  end
-
-  def test_feed_should_include_two_entries
-    with_restful_routing(:scrolls) do
-      get :index, :id => "defaults"
-      assert_select "entry", 2
-    end
-  end
-
-  def test_entry_should_only_use_published_if_created_at_is_present
-    with_restful_routing(:scrolls) do
-      get :index, :id => "defaults"
-      assert_select "published", 1
-    end
-  end
-
-  def test_providing_builder_to_atom_feed
-    with_restful_routing(:scrolls) do
-      get :index, :id=>"provide_builder"
-      # because we pass in the non-default builder, the content generated by the
-      # helper should go 'nowhere'.  Leaving the response body blank.
-      assert @response.body.blank?
-    end
-  end
-
-  def test_entry_with_prefilled_options_should_use_those_instead_of_querying_the_record
-    with_restful_routing(:scrolls) do
-      get :index, :id => "entry_options"
-
-      assert_select "updated", Time.utc(2007, 1, 1).xmlschema
-      assert_select "updated", Time.utc(2007, 1, 2).xmlschema
-    end
-  end
-
-  def test_self_url_should_default_to_current_request_url
-    with_restful_routing(:scrolls) do
-      get :index, :id => "defaults"
-      assert_select "link[rel=self][href=http://www.nextangle.com/scrolls?id=defaults]"
-    end
-  end
-
-  def test_feed_id_should_be_a_valid_tag
-    with_restful_routing(:scrolls) do
-      get :index, :id => "defaults"
-      assert_select "id", :text => "tag:www.nextangle.com,2008:/scrolls?id=defaults"
-    end
-  end
-
-  def test_entry_id_should_be_a_valid_tag
-    with_restful_routing(:scrolls) do
-      get :index, :id => "defaults"
-      assert_select "entry id", :text => "tag:www.nextangle.com,2008:Scroll/1"
-      assert_select "entry id", :text => "tag:www.nextangle.com,2008:Scroll/2"
-    end
-  end
-
-  def test_feed_should_allow_nested_xml_blocks
-    with_restful_routing(:scrolls) do
-      get :index, :id => "xml_block"
-      assert_select "author name", :text => "DHH"
-    end
-  end
-
-  def test_feed_should_include_atomPub_namespace
-    with_restful_routing(:scrolls) do
-      get :index, :id => "feed_with_atomPub_namespace"
-      assert_match %r{xml:lang="en-US"}, @response.body
-      assert_match %r{xmlns="http://www.w3.org/2005/Atom"}, @response.body
-      assert_match %r{xmlns:app="http://www.w3.org/2007/app"}, @response.body
-    end
-  end
-
-  def test_feed_should_allow_overriding_ids
-    with_restful_routing(:scrolls) do
-      get :index, :id => "feed_with_overridden_ids"
-      assert_select "id", :text => "tag:test.rubyonrails.org,2008:test/"
-      assert_select "entry id", :text => "tag:test.rubyonrails.org,2008:1"
-      assert_select "entry id", :text => "tag:test.rubyonrails.org,2008:2"
-    end
-  end
-
-  def test_feed_xml_processing_instructions
-    with_restful_routing(:scrolls) do
-      get :index, :id => 'feed_with_xml_processing_instructions'
-      assert_match %r{<\?xml-stylesheet [^\?]*type="text/css"}, @response.body
-      assert_match %r{<\?xml-stylesheet [^\?]*href="t.css"}, @response.body
-    end
-  end
-
-  def test_feed_xml_processing_instructions_duplicate_targets
-    with_restful_routing(:scrolls) do
-      get :index, :id => 'feed_with_xml_processing_instructions_duplicate_targets'
-      assert_match %r{<\?target1 (a="1" b="2"|b="2" a="1")\?>}, @response.body
-      assert_match %r{<\?target1 (c="3" d="4"|d="4" c="3")\?>}, @response.body
-    end
-  end
-
-  def test_feed_xhtml
-    with_restful_routing(:scrolls) do
-      get :index, :id => "feed_with_xhtml_content"
-      assert_match %r{xmlns="http://www.w3.org/1999/xhtml"}, @response.body
-      assert_select "summary div p", :text => "Something Boring"
-      assert_select "summary div p", :text => "after 2"
-    end
-  end
-
-  def test_feed_entry_type_option_default_to_text_html
-    with_restful_routing(:scrolls) do
-      get :index, :id => 'defaults'
-      assert_select "entry link[rel=alternate][type=text/html]"
-    end
-  end
-
-  def test_feed_entry_type_option_specified
-    with_restful_routing(:scrolls) do
-      get :index, :id => 'entry_type_options'
-      assert_select "entry link[rel=alternate][type=text/xml]"
-    end
-  end
-
-  private
-    def with_restful_routing(resources)
-      with_routing do |set|
-        set.draw do
-          resources(resources)
-        end
-        yield
-      end
-    end
-end
diff --git a/actionpack/test/template/capture_helper_test.rb b/actionpack/test/template/capture_helper_test.rb
deleted file mode 100644
index 938f1c3e54..0000000000
--- a/actionpack/test/template/capture_helper_test.rb
+++ /dev/null
@@ -1,242 +0,0 @@
-require 'abstract_unit'
-
-class CaptureHelperTest < ActionView::TestCase
-  def setup
-    super
-    @av = ActionView::Base.new
-    @view_flow = ActionView::OutputFlow.new
-  end
-
-  def test_capture_captures_the_temporary_output_buffer_in_its_block
-    assert_nil @av.output_buffer
-    string = @av.capture do
-      @av.output_buffer << 'foo'
-      @av.output_buffer << 'bar'
-    end
-    assert_nil @av.output_buffer
-    assert_equal 'foobar', string
-  end
-
-  def test_capture_captures_the_value_returned_by_the_block_if_the_temporary_buffer_is_blank
-    string = @av.capture('foo', 'bar') do |a, b|
-      a + b
-    end
-    assert_equal 'foobar', string
-  end
-
-  def test_capture_returns_nil_if_the_returned_value_is_not_a_string
-    assert_nil @av.capture { 1 }
-  end
-
-  def test_capture_escapes_html
-    string = @av.capture { '<em>bar</em>' }
-    assert_equal '&lt;em&gt;bar&lt;/em&gt;', string
-  end
-
-  def test_capture_doesnt_escape_twice
-    string = @av.capture { '&lt;em&gt;bar&lt;/em&gt;'.html_safe }
-    assert_equal '&lt;em&gt;bar&lt;/em&gt;', string
-  end
-
-  def test_capture_used_for_read
-    content_for :foo, "foo"
-    assert_equal "foo", content_for(:foo)
-
-    content_for(:bar){ "bar" }
-    assert_equal "bar", content_for(:bar)
-  end
-
-  def test_content_for_with_multiple_calls
-    assert ! content_for?(:title)
-    content_for :title, 'foo'
-    content_for :title, 'bar'
-    assert_equal 'foobar', content_for(:title)
-  end
-
-  def test_content_for_with_multiple_calls_and_flush
-    assert ! content_for?(:title)
-    content_for :title, 'foo'
-    content_for :title, 'bar', flush: true
-    assert_equal 'bar', content_for(:title)
-  end
-
-  def test_content_for_with_block
-    assert ! content_for?(:title)
-    content_for :title do
-      output_buffer << 'foo'
-      output_buffer << 'bar'
-      nil
-    end
-    assert_equal 'foobar', content_for(:title)
-  end
-
-  def test_content_for_with_block_and_multiple_calls_with_flush
-    assert ! content_for?(:title)
-    content_for :title do
-      'foo'
-    end
-    content_for :title, flush: true do
-      'bar'
-    end
-    assert_equal 'bar', content_for(:title)
-  end
-
-  def test_content_for_with_block_and_multiple_calls_with_flush_nil_content
-    assert ! content_for?(:title)
-    content_for :title do
-      'foo'
-    end
-    content_for :title, nil, flush: true do
-      'bar'
-    end
-    assert_equal 'bar', content_for(:title)
-  end
-
-  def test_content_for_with_block_and_multiple_calls_without_flush
-    assert ! content_for?(:title)
-    content_for :title do
-      'foo'
-    end
-    content_for :title, flush: false do
-      'bar'
-    end
-    assert_equal 'foobar', content_for(:title)
-  end
-
-  def test_content_for_with_whitespace_block
-    assert ! content_for?(:title)
-    content_for :title, 'foo'
-    content_for :title do
-      output_buffer << "  \n  "
-      nil
-    end
-    content_for :title, 'bar'
-    assert_equal 'foobar', content_for(:title)
-  end
-
-  def test_content_for_with_whitespace_block_and_flush
-    assert ! content_for?(:title)
-    content_for :title, 'foo'
-    content_for :title, flush: true do
-      output_buffer << "  \n  "
-      nil
-    end
-    content_for :title, 'bar', flush: true
-    assert_equal 'bar', content_for(:title)
-  end
-
-  def test_content_for_returns_nil_when_writing
-    assert ! content_for?(:title)
-    assert_equal nil, content_for(:title, 'foo')
-    assert_equal nil, content_for(:title) { output_buffer << 'bar'; nil }
-    assert_equal nil, content_for(:title) { output_buffer << "  \n  "; nil }
-    assert_equal 'foobar', content_for(:title)
-    assert_equal nil, content_for(:title, 'foo', flush: true)
-    assert_equal nil, content_for(:title, flush: true) { output_buffer << 'bar'; nil }
-    assert_equal nil, content_for(:title, flush: true) { output_buffer << "  \n  "; nil }
-    assert_equal 'bar', content_for(:title)
-  end
-
-  def test_content_for_returns_nil_when_content_missing
-    assert_equal nil, content_for(:some_missing_key)
-  end
-
-  def test_content_for_question_mark
-    assert ! content_for?(:title)
-    content_for :title, 'title'
-    assert content_for?(:title)
-    assert ! content_for?(:something_else)
-  end
-
-  def test_provide
-    assert !content_for?(:title)
-    provide :title, "hi"
-    assert content_for?(:title)
-    assert_equal "hi", content_for(:title)
-    provide :title, "<p>title</p>"
-    assert_equal "hi&lt;p&gt;title&lt;/p&gt;", content_for(:title)
-
-    @view_flow = ActionView::OutputFlow.new
-    provide :title, "hi"
-    provide :title, "<p>title</p>".html_safe
-    assert_equal "hi<p>title</p>", content_for(:title)
-  end
-
-  def test_with_output_buffer_swaps_the_output_buffer_given_no_argument
-    assert_nil @av.output_buffer
-    buffer = @av.with_output_buffer do
-      @av.output_buffer << '.'
-    end
-    assert_equal '.', buffer
-    assert_nil @av.output_buffer
-  end
-
-  def test_with_output_buffer_swaps_the_output_buffer_with_an_argument
-    assert_nil @av.output_buffer
-    buffer = ActionView::OutputBuffer.new('.')
-    @av.with_output_buffer(buffer) do
-      @av.output_buffer << '.'
-    end
-    assert_equal '..', buffer
-    assert_nil @av.output_buffer
-  end
-
-  def test_with_output_buffer_restores_the_output_buffer
-    buffer = ActionView::OutputBuffer.new
-    @av.output_buffer = buffer
-    @av.with_output_buffer do
-      @av.output_buffer << '.'
-    end
-    assert buffer.equal?(@av.output_buffer)
-  end
-
-  def test_with_output_buffer_sets_proper_encoding
-    @av.output_buffer = ActionView::OutputBuffer.new
-
-    # Ensure we set the output buffer to an encoding different than the default one.
-    alt_encoding = alt_encoding(@av.output_buffer)
-    @av.output_buffer.force_encoding(alt_encoding)
-
-    @av.with_output_buffer do
-      assert_equal alt_encoding, @av.output_buffer.encoding
-    end
-  end
-
-  def test_with_output_buffer_does_not_assume_there_is_an_output_buffer
-    assert_nil @av.output_buffer
-    assert_equal "", @av.with_output_buffer {}
-  end
-
-  def test_flush_output_buffer_concats_output_buffer_to_response
-    view = view_with_controller
-    assert_equal [], view.response.body_parts
-
-    view.output_buffer << 'OMG'
-    view.flush_output_buffer
-    assert_equal ['OMG'], view.response.body_parts
-    assert_equal '', view.output_buffer
-
-    view.output_buffer << 'foobar'
-    view.flush_output_buffer
-    assert_equal ['OMG', 'foobar'], view.response.body_parts
-    assert_equal '', view.output_buffer
-  end
-
-  def test_flush_output_buffer_preserves_the_encoding_of_the_output_buffer
-    view = view_with_controller
-    alt_encoding = alt_encoding(view.output_buffer)
-    view.output_buffer.force_encoding(alt_encoding)
-    flush_output_buffer
-    assert_equal alt_encoding, view.output_buffer.encoding
-  end
-
-  def alt_encoding(output_buffer)
-    output_buffer.encoding == Encoding::US_ASCII ? Encoding::UTF_8 : Encoding::US_ASCII
-  end
-
-  def view_with_controller
-    TestController.new.view_context.tap do |view|
-      view.output_buffer = ActionView::OutputBuffer.new
-    end
-  end
-end
diff --git a/actionpack/test/template/compiled_templates_test.rb b/actionpack/test/template/compiled_templates_test.rb
deleted file mode 100644
index f5dc2fbb33..0000000000
--- a/actionpack/test/template/compiled_templates_test.rb
+++ /dev/null
@@ -1,63 +0,0 @@
-require 'abstract_unit'
-require 'controller/fake_models'
-
-class CompiledTemplatesTest < ActiveSupport::TestCase
-  def setup
-    # Clean up any details key cached to expose failures
-    # that otherwise would appear just on isolated tests
-    ActionView::LookupContext::DetailsKey.clear
-
-    @compiled_templates = ActionView::CompiledTemplates
-    @compiled_templates.instance_methods.each do |m|
-      @compiled_templates.send(:remove_method, m) if m =~ /^_render_template_/
-    end
-  end
-
-  def test_template_gets_recompiled_when_using_different_keys_in_local_assigns
-    assert_equal "one", render(:file => "test/render_file_with_locals_and_default")
-    assert_equal "two", render(:file => "test/render_file_with_locals_and_default", :locals => { :secret => "two" })
-  end
-
-  def test_template_changes_are_not_reflected_with_cached_templates
-    assert_equal "Hello world!", render(:file => "test/hello_world")
-    modify_template "test/hello_world.erb", "Goodbye world!" do
-      assert_equal "Hello world!", render(:file => "test/hello_world")
-    end
-    assert_equal "Hello world!", render(:file => "test/hello_world")
-  end
-
-  def test_template_changes_are_reflected_with_uncached_templates
-    assert_equal "Hello world!", render_without_cache(:file => "test/hello_world")
-    modify_template "test/hello_world.erb", "Goodbye world!" do
-      assert_equal "Goodbye world!", render_without_cache(:file => "test/hello_world")
-    end
-    assert_equal "Hello world!", render_without_cache(:file => "test/hello_world")
-  end
-
-  private
-    def render(*args)
-      render_with_cache(*args)
-    end
-
-    def render_with_cache(*args)
-      view_paths = ActionController::Base.view_paths
-      ActionView::Base.new(view_paths, {}).render(*args)
-    end
-
-    def render_without_cache(*args)
-      path = ActionView::FileSystemResolver.new(FIXTURE_LOAD_PATH)
-      view_paths = ActionView::PathSet.new([path])
-      ActionView::Base.new(view_paths, {}).render(*args)
-    end
-
-    def modify_template(template, content)
-      filename = "#{FIXTURE_LOAD_PATH}/#{template}"
-      old_content = File.read(filename)
-      begin
-        File.open(filename, "wb+") { |f| f.write(content) }
-        yield
-      ensure
-        File.open(filename, "wb+") { |f| f.write(old_content) }
-      end
-    end
-end
diff --git a/actionpack/test/template/date_helper_i18n_test.rb b/actionpack/test/template/date_helper_i18n_test.rb
deleted file mode 100644
index 21fca35185..0000000000
--- a/actionpack/test/template/date_helper_i18n_test.rb
+++ /dev/null
@@ -1,148 +0,0 @@
-require 'abstract_unit'
-
-class DateHelperDistanceOfTimeInWordsI18nTests < ActiveSupport::TestCase
-  include ActionView::Helpers::DateHelper
-  attr_reader :request
-
-  def setup
-    @from = Time.utc(2004, 6, 6, 21, 45, 0)
-  end
-
-  # distance_of_time_in_words
-
-  def test_distance_of_time_in_words_calls_i18n
-    { # with include_seconds
-      [2.seconds,  { :include_seconds => true }]  => [:'less_than_x_seconds', 5],
-      [9.seconds,  { :include_seconds => true }]  => [:'less_than_x_seconds', 10],
-      [19.seconds, { :include_seconds => true }]  => [:'less_than_x_seconds', 20],
-      [30.seconds, { :include_seconds => true }]  => [:'half_a_minute',       nil],
-      [59.seconds, { :include_seconds => true }]  => [:'less_than_x_minutes', 1],
-      [60.seconds, { :include_seconds => true }]  => [:'x_minutes',           1],
-
-      # without include_seconds
-      [29.seconds,          { :include_seconds => false }] => [:'less_than_x_minutes', 1],
-      [60.seconds,          { :include_seconds => false }] => [:'x_minutes',           1],
-      [44.minutes,          { :include_seconds => false }] => [:'x_minutes',           44],
-      [61.minutes,          { :include_seconds => false }] => [:'about_x_hours',       1],
-      [24.hours,            { :include_seconds => false }] => [:'x_days',              1],
-      [30.days,             { :include_seconds => false }] => [:'about_x_months',      1],
-      [60.days,             { :include_seconds => false }] => [:'x_months',            2],
-      [1.year,              { :include_seconds => false }] => [:'about_x_years',       1],
-      [3.years + 6.months,  { :include_seconds => false }] => [:'over_x_years',        3],
-      [3.years + 10.months, { :include_seconds => false }] => [:'almost_x_years',      4]
-
-      }.each do |passed, expected|
-      assert_distance_of_time_in_words_translates_key passed, expected
-    end
-  end
-
-  def test_distance_of_time_in_words_calls_i18n_with_custom_scope
-    {
-      [30.days, { scope: :'datetime.distance_in_words_ago' }] => [:'about_x_months', 1],
-      [60.days, { scope: :'datetime.distance_in_words_ago' }] => [:'x_months',       2],
-    }.each do |passed, expected|
-      assert_distance_of_time_in_words_translates_key(passed, expected, scope: :'datetime.distance_in_words_ago')
-    end
-  end
-
-  def test_time_ago_in_words_passes_locale
-    I18n.expects(:t).with(:less_than_x_minutes, :scope => :'datetime.distance_in_words', :count => 1, :locale => 'ru')
-    time_ago_in_words(15.seconds.ago, :locale => 'ru')
-  end
-
-  def test_distance_of_time_pluralizations
-    { [:'less_than_x_seconds', 1]   => 'less than 1 second',
-      [:'less_than_x_seconds', 2]   => 'less than 2 seconds',
-      [:'less_than_x_minutes', 1]   => 'less than a minute',
-      [:'less_than_x_minutes', 2]   => 'less than 2 minutes',
-      [:'x_minutes',           1]   => '1 minute',
-      [:'x_minutes',           2]   => '2 minutes',
-      [:'about_x_hours',       1]   => 'about 1 hour',
-      [:'about_x_hours',       2]   => 'about 2 hours',
-      [:'x_days',              1]   => '1 day',
-      [:'x_days',              2]   => '2 days',
-      [:'about_x_years',       1]   => 'about 1 year',
-      [:'about_x_years',       2]   => 'about 2 years',
-      [:'over_x_years',        1]   => 'over 1 year',
-      [:'over_x_years',        2]   => 'over 2 years'
-
-      }.each do |args, expected|
-      key, count = *args
-      assert_equal expected, I18n.t(key, :count => count, :scope => 'datetime.distance_in_words')
-    end
-  end
-
-  def assert_distance_of_time_in_words_translates_key(passed, expected, expected_options = {})
-    diff, passed_options = *passed
-    key, count = *expected
-    to = @from + diff
-
-    options = { locale: 'en', scope: :'datetime.distance_in_words' }.merge!(expected_options)
-    options[:count] = count if count
-
-    I18n.expects(:t).with(key, options)
-    distance_of_time_in_words(@from, to, passed_options.merge(locale: 'en'))
-  end
-end
-
-class DateHelperSelectTagsI18nTests < ActiveSupport::TestCase
-  include ActionView::Helpers::DateHelper
-  attr_reader :request
-
-  def setup
-    @prompt_defaults = {:year => 'Year', :month => 'Month', :day => 'Day', :hour => 'Hour', :minute => 'Minute', :second => 'Seconds'}
-
-    I18n.stubs(:translate).with(:'date.month_names', :locale => 'en').returns Date::MONTHNAMES
-  end
-
-  # select_month
-
-  def test_select_month_given_use_month_names_option_does_not_translate_monthnames
-    I18n.expects(:translate).never
-    select_month(8, :locale => 'en', :use_month_names => Date::MONTHNAMES)
-  end
-
-  def test_select_month_translates_monthnames
-    I18n.expects(:translate).with(:'date.month_names', :locale => 'en').returns Date::MONTHNAMES
-    select_month(8, :locale => 'en')
-  end
-
-  def test_select_month_given_use_short_month_option_translates_abbr_monthnames
-    I18n.expects(:translate).with(:'date.abbr_month_names', :locale => 'en').returns Date::ABBR_MONTHNAMES
-    select_month(8, :locale => 'en', :use_short_month => true)
-  end
-
-  def test_date_or_time_select_translates_prompts
-    @prompt_defaults.each do |key, prompt|
-      I18n.expects(:translate).with(('datetime.prompts.' + key.to_s).to_sym, :locale => 'en').returns prompt
-    end
-
-    I18n.expects(:translate).with(:'date.order', :locale => 'en', :default => []).returns %w(year month day)
-    datetime_select('post', 'updated_at', :locale => 'en', :include_seconds => true, :prompt => true)
-  end
-
-  # date_or_time_select
-
-  def test_date_or_time_select_given_an_order_options_does_not_translate_order
-    I18n.expects(:translate).never
-    datetime_select('post', 'updated_at', :order => [:year, :month, :day], :locale => 'en')
-  end
-
-  def test_date_or_time_select_given_no_order_options_translates_order
-    I18n.expects(:translate).with(:'date.order', :locale => 'en', :default => []).returns %w(year month day)
-    datetime_select('post', 'updated_at', :locale => 'en')
-  end
-
-  def test_date_or_time_select_given_invalid_order
-    I18n.expects(:translate).with(:'date.order', :locale => 'en', :default => []).returns %w(invalid month day)
-
-    assert_raise StandardError do
-      datetime_select('post', 'updated_at', :locale => 'en')
-    end
-  end
-
-  def test_date_or_time_select_given_symbol_keys
-    I18n.expects(:translate).with(:'date.order', :locale => 'en', :default => []).returns [:year, :month, :day]
-    datetime_select('post', 'updated_at', :locale => 'en')
-  end
-end
diff --git a/actionpack/test/template/date_helper_test.rb b/actionpack/test/template/date_helper_test.rb
deleted file mode 100644
index 242b56a1fd..0000000000
--- a/actionpack/test/template/date_helper_test.rb
+++ /dev/null
@@ -1,3199 +0,0 @@
-require 'abstract_unit'
-
-class DateHelperTest < ActionView::TestCase
-  tests ActionView::Helpers::DateHelper
-
-  silence_warnings do
-    Post = Struct.new("Post", :id, :written_on, :updated_at)
-    Post.class_eval do
-      def id
-        123
-      end
-      def id_before_type_cast
-        123
-      end
-      def to_param
-        '123'
-      end
-    end
-  end
-
-  def assert_distance_of_time_in_words(from, to=nil)
-    Fixnum.send :private, :/  # test we avoid Integer#/ (redefined by mathn)
-
-    to ||= from
-
-    # 0..1 minute with :include_seconds => true
-    assert_equal "less than 5 seconds", distance_of_time_in_words(from, to + 0.seconds, :include_seconds => true)
-    assert_equal "less than 5 seconds", distance_of_time_in_words(from, to + 4.seconds, :include_seconds => true)
-    assert_equal "less than 10 seconds", distance_of_time_in_words(from, to + 5.seconds, :include_seconds => true)
-    assert_equal "less than 10 seconds", distance_of_time_in_words(from, to + 9.seconds, :include_seconds => true)
-    assert_equal "less than 20 seconds", distance_of_time_in_words(from, to + 10.seconds, :include_seconds => true)
-    assert_equal "less than 20 seconds", distance_of_time_in_words(from, to + 19.seconds, :include_seconds => true)
-    assert_equal "half a minute", distance_of_time_in_words(from, to + 20.seconds, :include_seconds => true)
-    assert_equal "half a minute", distance_of_time_in_words(from, to + 39.seconds, :include_seconds => true)
-    assert_equal "less than a minute", distance_of_time_in_words(from, to + 40.seconds, :include_seconds => true)
-    assert_equal "less than a minute", distance_of_time_in_words(from, to + 59.seconds, :include_seconds => true)
-    assert_equal "1 minute", distance_of_time_in_words(from, to + 60.seconds, :include_seconds => true)
-    assert_equal "1 minute", distance_of_time_in_words(from, to + 89.seconds, :include_seconds => true)
-
-    # 0..1 minute with :include_seconds => false
-    assert_equal "less than a minute", distance_of_time_in_words(from, to + 0.seconds, :include_seconds => false)
-    assert_equal "less than a minute", distance_of_time_in_words(from, to + 4.seconds, :include_seconds => false)
-    assert_equal "less than a minute", distance_of_time_in_words(from, to + 5.seconds, :include_seconds => false)
-    assert_equal "less than a minute", distance_of_time_in_words(from, to + 9.seconds, :include_seconds => false)
-    assert_equal "less than a minute", distance_of_time_in_words(from, to + 10.seconds, :include_seconds => false)
-    assert_equal "less than a minute", distance_of_time_in_words(from, to + 19.seconds, :include_seconds => false)
-    assert_equal "less than a minute", distance_of_time_in_words(from, to + 20.seconds, :include_seconds => false)
-    assert_equal "1 minute", distance_of_time_in_words(from, to + 39.seconds, :include_seconds => false)
-    assert_equal "1 minute", distance_of_time_in_words(from, to + 40.seconds, :include_seconds => false)
-    assert_equal "1 minute", distance_of_time_in_words(from, to + 59.seconds, :include_seconds => false)
-    assert_equal "1 minute", distance_of_time_in_words(from, to + 60.seconds, :include_seconds => false)
-    assert_equal "1 minute", distance_of_time_in_words(from, to + 89.seconds, :include_seconds => false)
-
-    # Note that we are including a 30-second boundary around the interval we
-    # want to test. For instance, "1 minute" is actually 30s to 1m29s. The
-    # reason for doing this is simple -- in `distance_of_time_to_words`, when we
-    # take the distance between our two Time objects in seconds and convert it
-    # to minutes, we round the number. So 29s gets rounded down to 0m, 30s gets
-    # rounded up to 1m, and 1m29s gets rounded down to 1m. A similar thing
-    # happens with the other cases.
-
-    # First case 0..1 minute
-    assert_equal "less than a minute", distance_of_time_in_words(from, to + 0.seconds)
-    assert_equal "less than a minute", distance_of_time_in_words(from, to + 29.seconds)
-    assert_equal "1 minute", distance_of_time_in_words(from, to + 30.seconds)
-    assert_equal "1 minute", distance_of_time_in_words(from, to + 1.minutes + 29.seconds)
-
-    # 2 minutes up to 45 minutes
-    assert_equal "2 minutes", distance_of_time_in_words(from, to + 1.minutes + 30.seconds)
-    assert_equal "44 minutes", distance_of_time_in_words(from, to + 44.minutes + 29.seconds)
-
-    # 45 minutes up to 90 minutes
-    assert_equal "about 1 hour", distance_of_time_in_words(from, to + 44.minutes + 30.seconds)
-    assert_equal "about 1 hour", distance_of_time_in_words(from, to + 89.minutes + 29.seconds)
-
-    # 90 minutes up to 24 hours
-    assert_equal "about 2 hours", distance_of_time_in_words(from, to + 89.minutes + 30.seconds)
-    assert_equal "about 24 hours", distance_of_time_in_words(from, to + 23.hours + 59.minutes + 29.seconds)
-
-    # 24 hours up to 42 hours
-    assert_equal "1 day", distance_of_time_in_words(from, to + 23.hours + 59.minutes + 30.seconds)
-    assert_equal "1 day", distance_of_time_in_words(from, to + 41.hours + 59.minutes + 29.seconds)
-
-    # 42 hours up to 30 days
-    assert_equal "2 days", distance_of_time_in_words(from, to + 41.hours + 59.minutes + 30.seconds)
-    assert_equal "3 days", distance_of_time_in_words(from, to + 2.days + 12.hours)
-    assert_equal "30 days", distance_of_time_in_words(from, to + 29.days + 23.hours + 59.minutes + 29.seconds)
-
-    # 30 days up to 60 days
-    assert_equal "about 1 month", distance_of_time_in_words(from, to + 29.days + 23.hours + 59.minutes + 30.seconds)
-    assert_equal "about 1 month", distance_of_time_in_words(from, to + 44.days + 23.hours + 59.minutes + 29.seconds)
-    assert_equal "about 2 months", distance_of_time_in_words(from, to + 44.days + 23.hours + 59.minutes + 30.seconds)
-    assert_equal "about 2 months", distance_of_time_in_words(from, to + 59.days + 23.hours + 59.minutes + 29.seconds)
-
-    # 60 days up to 365 days
-    assert_equal "2 months", distance_of_time_in_words(from, to + 59.days + 23.hours + 59.minutes + 30.seconds)
-    assert_equal "12 months", distance_of_time_in_words(from, to + 1.years - 31.seconds)
-
-    # >= 365 days
-    assert_equal "about 1 year",    distance_of_time_in_words(from, to + 1.years - 30.seconds)
-    assert_equal "about 1 year",    distance_of_time_in_words(from, to + 1.years + 3.months - 1.day)
-    assert_equal "over 1 year",     distance_of_time_in_words(from, to + 1.years + 6.months)
-
-    assert_equal "almost 2 years",  distance_of_time_in_words(from, to + 2.years - 3.months + 1.day)
-    assert_equal "about 2 years",   distance_of_time_in_words(from, to + 2.years + 3.months - 1.day)
-    assert_equal "over 2 years",    distance_of_time_in_words(from, to + 2.years + 3.months + 1.day)
-    assert_equal "over 2 years",    distance_of_time_in_words(from, to + 2.years + 9.months - 1.day)
-    assert_equal "almost 3 years",  distance_of_time_in_words(from, to + 2.years + 9.months + 1.day)
-
-    assert_equal "almost 5 years",  distance_of_time_in_words(from, to + 5.years - 3.months + 1.day)
-    assert_equal "about 5 years",   distance_of_time_in_words(from, to + 5.years + 3.months - 1.day)
-    assert_equal "over 5 years",    distance_of_time_in_words(from, to + 5.years + 3.months + 1.day)
-    assert_equal "over 5 years",    distance_of_time_in_words(from, to + 5.years + 9.months - 1.day)
-    assert_equal "almost 6 years",  distance_of_time_in_words(from, to + 5.years + 9.months + 1.day)
-
-    assert_equal "almost 10 years", distance_of_time_in_words(from, to + 10.years - 3.months + 1.day)
-    assert_equal "about 10 years",  distance_of_time_in_words(from, to + 10.years + 3.months - 1.day)
-    assert_equal "over 10 years",   distance_of_time_in_words(from, to + 10.years + 3.months + 1.day)
-    assert_equal "over 10 years",   distance_of_time_in_words(from, to + 10.years + 9.months - 1.day)
-    assert_equal "almost 11 years", distance_of_time_in_words(from, to + 10.years + 9.months + 1.day)
-
-    # test to < from
-    assert_equal "about 4 hours", distance_of_time_in_words(from + 4.hours, to)
-    assert_equal "less than 20 seconds", distance_of_time_in_words(from + 19.seconds, to, :include_seconds => true)
-    assert_equal "less than a minute", distance_of_time_in_words(from + 19.seconds, to, :include_seconds => false)
-
-  ensure
-    Fixnum.send :public, :/
-  end
-
-  def test_distance_in_words
-    from = Time.utc(2004, 6, 6, 21, 45, 0)
-    assert_distance_of_time_in_words(from)
-  end
-
-  def test_time_ago_in_words_passes_include_seconds
-    assert_equal "less than 20 seconds", time_ago_in_words(15.seconds.ago, :include_seconds => true)
-    assert_equal "less than a minute", time_ago_in_words(15.seconds.ago, :include_seconds => false)
-  end
-
-  def test_distance_in_words_with_time_zones
-    from = Time.mktime(2004, 6, 6, 21, 45, 0)
-    assert_distance_of_time_in_words(from.in_time_zone('Alaska'))
-    assert_distance_of_time_in_words(from.in_time_zone('Hawaii'))
-  end
-
-  def test_distance_in_words_with_different_time_zones
-    from = Time.mktime(2004, 6, 6, 21, 45, 0)
-    assert_distance_of_time_in_words(
-      from.in_time_zone('Alaska'),
-      from.in_time_zone('Hawaii')
-    )
-  end
-
-  def test_distance_in_words_with_dates
-    start_date = Date.new 1975, 1, 31
-    end_date = Date.new 1977, 1, 31
-    assert_equal("about 2 years", distance_of_time_in_words(start_date, end_date))
-
-    start_date = Date.new 1982, 12, 3
-    end_date = Date.new 2010, 11, 30
-    assert_equal("almost 28 years", distance_of_time_in_words(start_date, end_date))
-    assert_equal("almost 28 years", distance_of_time_in_words(end_date, start_date))
-  end
-
-  def test_distance_in_words_with_integers
-    assert_equal "1 minute", distance_of_time_in_words(59)
-    assert_equal "about 1 hour", distance_of_time_in_words(60*60)
-    assert_equal "1 minute", distance_of_time_in_words(0, 59)
-    assert_equal "about 1 hour", distance_of_time_in_words(60*60, 0)
-    assert_equal "about 3 years", distance_of_time_in_words(10**8)
-    assert_equal "about 3 years", distance_of_time_in_words(0, 10**8)
-  end
-
-  def test_distance_in_words_with_times
-    assert_equal "1 minute", distance_of_time_in_words(30.seconds)
-    assert_equal "1 minute", distance_of_time_in_words(59.seconds)
-    assert_equal "2 minutes", distance_of_time_in_words(119.seconds)
-    assert_equal "2 minutes", distance_of_time_in_words(1.minute + 59.seconds)
-    assert_equal "3 minutes", distance_of_time_in_words(2.minute + 30.seconds)
-    assert_equal "44 minutes", distance_of_time_in_words(44.minutes + 29.seconds)
-    assert_equal "about 1 hour", distance_of_time_in_words(44.minutes + 30.seconds)
-    assert_equal "about 1 hour", distance_of_time_in_words(60.minutes)
-
-    # include seconds
-    assert_equal "half a minute", distance_of_time_in_words(39.seconds, 0, :include_seconds => true)
-    assert_equal "less than a minute", distance_of_time_in_words(40.seconds, 0, :include_seconds => true)
-    assert_equal "less than a minute", distance_of_time_in_words(59.seconds, 0, :include_seconds => true)
-    assert_equal "1 minute", distance_of_time_in_words(60.seconds, 0, :include_seconds => true)
-  end
-
-  def test_time_ago_in_words
-    assert_equal "about 1 year", time_ago_in_words(1.year.ago - 1.day)
-  end
-
-  def test_select_day
-    expected = %(<select id="date_day" name="date[day]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_day(Time.mktime(2003, 8, 16))
-    assert_dom_equal expected, select_day(16)
-  end
-
-  def test_select_day_with_blank
-    expected = %(<select id="date_day" name="date[day]">\n)
-    expected << %(<option value=""></option>\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_day(Time.mktime(2003, 8, 16), :include_blank => true)
-    assert_dom_equal expected, select_day(16, :include_blank => true)
-  end
-
-  def test_select_day_nil_with_blank
-    expected = %(<select id="date_day" name="date[day]">\n)
-    expected << %(<option value=""></option>\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_day(nil, :include_blank => true)
-  end
-
-  def test_select_day_with_two_digit_numbers
-    expected = %(<select id="date_day" name="date[day]">\n)
-    expected << %(<option value="1">01</option>\n<option selected="selected" value="2">02</option>\n<option value="3">03</option>\n<option value="4">04</option>\n<option value="5">05</option>\n<option value="6">06</option>\n<option value="7">07</option>\n<option value="8">08</option>\n<option value="9">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_day(Time.mktime(2011, 8, 2), :use_two_digit_numbers => true)
-    assert_dom_equal expected, select_day(2, :use_two_digit_numbers => true)
-  end
-
-  def test_select_day_with_html_options
-    expected = %(<select id="date_day" name="date[day]" class="selector">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_day(Time.mktime(2003, 8, 16), {}, :class => 'selector')
-    assert_dom_equal expected, select_day(16, {}, :class => 'selector')
-  end
-
-  def test_select_day_with_default_prompt
-    expected = %(<select id="date_day" name="date[day]">\n)
-    expected << %(<option value="">Day</option>\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_day(16, :prompt => true)
-  end
-
-  def test_select_day_with_custom_prompt
-    expected = %(<select id="date_day" name="date[day]">\n)
-    expected << %(<option value="">Choose day</option>\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_day(16, :prompt => 'Choose day')
-  end
-
-  def test_select_month
-    expected = %(<select id="date_month" name="date[month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_month(Time.mktime(2003, 8, 16))
-    assert_dom_equal expected, select_month(8)
-  end
-
-  def test_select_month_with_two_digit_numbers
-    expected = %(<select id="date_month" name="date[month]">\n)
-    expected << %(<option value="1">01</option>\n<option value="2">02</option>\n<option value="3">03</option>\n<option value="4">04</option>\n<option value="5">05</option>\n<option value="6">06</option>\n<option value="7">07</option>\n<option value="8" selected="selected">08</option>\n<option value="9">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_month(Time.mktime(2011, 8, 16), :use_two_digit_numbers => true)
-    assert_dom_equal expected, select_month(8, :use_two_digit_numbers => true)
-  end
-
-  def test_select_month_with_disabled
-    expected = %(<select id="date_month" name="date[month]" disabled="disabled">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_month(Time.mktime(2003, 8, 16), :disabled => true)
-    assert_dom_equal expected, select_month(8, :disabled => true)
-  end
-
-  def test_select_month_with_field_name_override
-    expected = %(<select id="date_mois" name="date[mois]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_month(Time.mktime(2003, 8, 16), :field_name => 'mois')
-    assert_dom_equal expected, select_month(8, :field_name => 'mois')
-  end
-
-  def test_select_month_with_blank
-    expected = %(<select id="date_month" name="date[month]">\n)
-    expected << %(<option value=""></option>\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_month(Time.mktime(2003, 8, 16), :include_blank => true)
-    assert_dom_equal expected, select_month(8, :include_blank => true)
-  end
-
-  def test_select_month_nil_with_blank
-    expected = %(<select id="date_month" name="date[month]">\n)
-    expected << %(<option value=""></option>\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_month(nil, :include_blank => true)
-  end
-
-  def test_select_month_with_numbers
-    expected = %(<select id="date_month" name="date[month]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8" selected="selected">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_month(Time.mktime(2003, 8, 16), :use_month_numbers => true)
-    assert_dom_equal expected, select_month(8, :use_month_numbers => true)
-  end
-
-  def test_select_month_with_numbers_and_names
-    expected = %(<select id="date_month" name="date[month]">\n)
-    expected << %(<option value="1">1 - January</option>\n<option value="2">2 - February</option>\n<option value="3">3 - March</option>\n<option value="4">4 - April</option>\n<option value="5">5 - May</option>\n<option value="6">6 - June</option>\n<option value="7">7 - July</option>\n<option value="8" selected="selected">8 - August</option>\n<option value="9">9 - September</option>\n<option value="10">10 - October</option>\n<option value="11">11 - November</option>\n<option value="12">12 - December</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_month(Time.mktime(2003, 8, 16), :add_month_numbers => true)
-    assert_dom_equal expected, select_month(8, :add_month_numbers => true)
-  end
-
-  def test_select_month_with_numbers_and_names_with_abbv
-    expected = %(<select id="date_month" name="date[month]">\n)
-    expected << %(<option value="1">1 - Jan</option>\n<option value="2">2 - Feb</option>\n<option value="3">3 - Mar</option>\n<option value="4">4 - Apr</option>\n<option value="5">5 - May</option>\n<option value="6">6 - Jun</option>\n<option value="7">7 - Jul</option>\n<option value="8" selected="selected">8 - Aug</option>\n<option value="9">9 - Sep</option>\n<option value="10">10 - Oct</option>\n<option value="11">11 - Nov</option>\n<option value="12">12 - Dec</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_month(Time.mktime(2003, 8, 16), :add_month_numbers => true, :use_short_month => true)
-    assert_dom_equal expected, select_month(8, :add_month_numbers => true, :use_short_month => true)
-  end
-
-  def test_select_month_with_abbv
-    expected = %(<select id="date_month" name="date[month]">\n)
-    expected << %(<option value="1">Jan</option>\n<option value="2">Feb</option>\n<option value="3">Mar</option>\n<option value="4">Apr</option>\n<option value="5">May</option>\n<option value="6">Jun</option>\n<option value="7">Jul</option>\n<option value="8" selected="selected">Aug</option>\n<option value="9">Sep</option>\n<option value="10">Oct</option>\n<option value="11">Nov</option>\n<option value="12">Dec</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_month(Time.mktime(2003, 8, 16), :use_short_month => true)
-    assert_dom_equal expected, select_month(8, :use_short_month => true)
-  end
-
-  def test_select_month_with_custom_names
-    month_names = %w(nil Januar Februar Marts April Maj Juni Juli August September Oktober November December)
-
-    expected = %(<select id="date_month" name="date[month]">\n)
-    1.upto(12) { |month| expected << %(<option value="#{month}"#{' selected="selected"' if month == 8}>#{month_names[month]}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_month(Time.mktime(2003, 8, 16), :use_month_names => month_names)
-    assert_dom_equal expected, select_month(8, :use_month_names => month_names)
-  end
-
-  def test_select_month_with_zero_indexed_custom_names
-    month_names = %w(Januar Februar Marts April Maj Juni Juli August September Oktober November December)
-
-    expected = %(<select id="date_month" name="date[month]">\n)
-    1.upto(12) { |month| expected << %(<option value="#{month}"#{' selected="selected"' if month == 8}>#{month_names[month-1]}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_month(Time.mktime(2003, 8, 16), :use_month_names => month_names)
-    assert_dom_equal expected, select_month(8, :use_month_names => month_names)
-  end
-
-  def test_select_month_with_hidden
-    assert_dom_equal "<input type=\"hidden\" id=\"date_month\" name=\"date[month]\" value=\"8\" />\n", select_month(8, :use_hidden => true)
-  end
-
-  def test_select_month_with_hidden_and_field_name
-    assert_dom_equal "<input type=\"hidden\" id=\"date_mois\" name=\"date[mois]\" value=\"8\" />\n", select_month(8, :use_hidden => true, :field_name => 'mois')
-  end
-
-  def test_select_month_with_html_options
-    expected = %(<select id="date_month" name="date[month]" class="selector" accesskey="M">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_month(Time.mktime(2003, 8, 16), {}, :class => 'selector', :accesskey => 'M')
-    #result = select_month(Time.mktime(2003, 8, 16), {}, :class => 'selector', :accesskey => 'M')
-    #assert result.include?('<select id="date_month" name="date[month]"')
-    #assert result.include?('class="selector"')
-    #assert result.include?('accesskey="M"')
-    #assert result.include?('<option value="1">January')
-  end
-
-  def test_select_month_with_default_prompt
-    expected = %(<select id="date_month" name="date[month]">\n)
-    expected << %(<option value="">Month</option>\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_month(8, :prompt => true)
-  end
-
-  def test_select_month_with_custom_prompt
-    expected = %(<select id="date_month" name="date[month]">\n)
-    expected << %(<option value="">Choose month</option>\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_month(8, :prompt => 'Choose month')
-  end
-
-  def test_select_year
-    expected = %(<select id="date_year" name="date[year]">\n)
-    expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_year(Time.mktime(2003, 8, 16), :start_year => 2003, :end_year => 2005)
-    assert_dom_equal expected, select_year(2003, :start_year => 2003, :end_year => 2005)
-  end
-
-  def test_select_year_with_disabled
-    expected = %(<select id="date_year" name="date[year]" disabled="disabled">\n)
-    expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_year(Time.mktime(2003, 8, 16), :disabled => true, :start_year => 2003, :end_year => 2005)
-    assert_dom_equal expected, select_year(2003, :disabled => true, :start_year => 2003, :end_year => 2005)
-  end
-
-  def test_select_year_with_field_name_override
-    expected = %(<select id="date_annee" name="date[annee]">\n)
-    expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_year(Time.mktime(2003, 8, 16), :start_year => 2003, :end_year => 2005, :field_name => 'annee')
-    assert_dom_equal expected, select_year(2003, :start_year => 2003, :end_year => 2005, :field_name => 'annee')
-  end
-
-  def test_select_year_with_type_discarding
-    expected = %(<select id="date_year" name="date_year">\n)
-    expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_year(
-      Time.mktime(2003, 8, 16), :prefix => "date_year", :discard_type => true, :start_year => 2003, :end_year => 2005)
-    assert_dom_equal expected, select_year(
-      2003, :prefix => "date_year", :discard_type => true, :start_year => 2003, :end_year => 2005)
-  end
-
-  def test_select_year_descending
-    expected = %(<select id="date_year" name="date[year]">\n)
-    expected << %(<option value="2005" selected="selected">2005</option>\n<option value="2004">2004</option>\n<option value="2003">2003</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_year(Time.mktime(2005, 8, 16), :start_year => 2005, :end_year => 2003)
-    assert_dom_equal expected, select_year(2005, :start_year => 2005, :end_year => 2003)
-  end
-
-  def test_select_year_with_hidden
-    assert_dom_equal "<input type=\"hidden\" id=\"date_year\" name=\"date[year]\" value=\"2007\" />\n", select_year(2007, :use_hidden => true)
-  end
-
-  def test_select_year_with_hidden_and_field_name
-    assert_dom_equal "<input type=\"hidden\" id=\"date_anno\" name=\"date[anno]\" value=\"2007\" />\n", select_year(2007, :use_hidden => true, :field_name => 'anno')
-  end
-
-  def test_select_year_with_html_options
-    expected = %(<select id="date_year" name="date[year]" class="selector" accesskey="M">\n)
-    expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_year(Time.mktime(2003, 8, 16), {:start_year => 2003, :end_year => 2005}, :class => 'selector', :accesskey => 'M')
-    #result = select_year(Time.mktime(2003, 8, 16), {:start_year => 2003, :end_year => 2005}, :class => 'selector', :accesskey => 'M')
-    #assert result.include?('<select id="date_year" name="date[year]"')
-    #assert result.include?('class="selector"')
-    #assert result.include?('accesskey="M"')
-    #assert result.include?('<option value="2003"')
-  end
-
-  def test_select_year_with_default_prompt
-    expected = %(<select id="date_year" name="date[year]">\n)
-    expected << %(<option value="">Year</option>\n<option value="2003">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_year(nil, :start_year => 2003, :end_year => 2005, :prompt => true)
-  end
-
-  def test_select_year_with_custom_prompt
-    expected = %(<select id="date_year" name="date[year]">\n)
-    expected << %(<option value="">Choose year</option>\n<option value="2003">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_year(nil, :start_year => 2003, :end_year => 2005, :prompt => 'Choose year')
-  end
-
-  def test_select_hour
-    expected = %(<select id="date_hour" name="date[hour]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_hour(Time.mktime(2003, 8, 16, 8, 4, 18))
-  end
-
-  def test_select_hour_with_ampm
-    expected = %(<select id="date_hour" name="date[hour]">\n)
-    expected << %(<option value="00">12 AM</option>\n<option value="01">01 AM</option>\n<option value="02">02 AM</option>\n<option value="03">03 AM</option>\n<option value="04">04 AM</option>\n<option value="05">05 AM</option>\n<option value="06">06 AM</option>\n<option value="07">07 AM</option>\n<option value="08" selected="selected">08 AM</option>\n<option value="09">09 AM</option>\n<option value="10">10 AM</option>\n<option value="11">11 AM</option>\n<option value="12">12 PM</option>\n<option value="13">01 PM</option>\n<option value="14">02 PM</option>\n<option value="15">03 PM</option>\n<option value="16">04 PM</option>\n<option value="17">05 PM</option>\n<option value="18">06 PM</option>\n<option value="19">07 PM</option>\n<option value="20">08 PM</option>\n<option value="21">09 PM</option>\n<option value="22">10 PM</option>\n<option value="23">11 PM</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_hour(Time.mktime(2003, 8, 16, 8, 4, 18), :ampm => true)
-  end
-
-  def test_select_hour_with_disabled
-    expected = %(<select id="date_hour" name="date[hour]" disabled="disabled">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_hour(Time.mktime(2003, 8, 16, 8, 4, 18), :disabled => true)
-  end
-
-  def test_select_hour_with_field_name_override
-    expected = %(<select id="date_heure" name="date[heure]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_hour(Time.mktime(2003, 8, 16, 8, 4, 18), :field_name => 'heure')
-  end
-
-  def test_select_hour_with_blank
-    expected = %(<select id="date_hour" name="date[hour]">\n)
-    expected << %(<option value=""></option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_hour(Time.mktime(2003, 8, 16, 8, 4, 18), :include_blank => true)
-  end
-
-  def test_select_hour_nil_with_blank
-    expected = %(<select id="date_hour" name="date[hour]">\n)
-    expected << %(<option value=""></option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_hour(nil, :include_blank => true)
-  end
-
-  def test_select_hour_with_html_options
-    expected = %(<select id="date_hour" name="date[hour]" class="selector" accesskey="M">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_hour(Time.mktime(2003, 8, 16, 8, 4, 18), {}, :class => 'selector', :accesskey => 'M')
-  end
-
-  def test_select_hour_with_default_prompt
-    expected = %(<select id="date_hour" name="date[hour]">\n)
-    expected << %(<option value="">Hour</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_hour(Time.mktime(2003, 8, 16, 8, 4, 18), :prompt => true)
-  end
-
-  def test_select_hour_with_custom_prompt
-    expected = %(<select id="date_hour" name="date[hour]">\n)
-    expected << %(<option value="">Choose hour</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_hour(Time.mktime(2003, 8, 16, 8, 4, 18), :prompt => 'Choose hour')
-  end
-
-  def test_select_minute
-    expected = %(<select id="date_minute" name="date[minute]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_minute(Time.mktime(2003, 8, 16, 8, 4, 18))
-  end
-
-  def test_select_minute_with_disabled
-    expected = %(<select id="date_minute" name="date[minute]" disabled="disabled">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_minute(Time.mktime(2003, 8, 16, 8, 4, 18), :disabled => true)
-  end
-
-  def test_select_minute_with_field_name_override
-    expected = %(<select id="date_minuto" name="date[minuto]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_minute(Time.mktime(2003, 8, 16, 8, 4, 18), :field_name => 'minuto')
-  end
-
-  def test_select_minute_with_blank
-    expected = %(<select id="date_minute" name="date[minute]">\n)
-    expected << %(<option value=""></option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_minute(Time.mktime(2003, 8, 16, 8, 4, 18), :include_blank => true)
-  end
-
-  def test_select_minute_with_blank_and_step
-    expected = %(<select id="date_minute" name="date[minute]">\n)
-    expected << %(<option value=""></option>\n<option value="00">00</option>\n<option value="15">15</option>\n<option value="30">30</option>\n<option value="45">45</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_minute(Time.mktime(2003, 8, 16, 8, 4, 18), { :include_blank => true , :minute_step => 15 })
-  end
-
-  def test_select_minute_nil_with_blank
-    expected = %(<select id="date_minute" name="date[minute]">\n)
-    expected << %(<option value=""></option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_minute(nil, :include_blank => true)
-  end
-
-  def test_select_minute_nil_with_blank_and_step
-    expected = %(<select id="date_minute" name="date[minute]">\n)
-    expected << %(<option value=""></option>\n<option value="00">00</option>\n<option value="15">15</option>\n<option value="30">30</option>\n<option value="45">45</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_minute(nil, { :include_blank => true , :minute_step => 15 })
-  end
-
-  def test_select_minute_with_hidden
-    assert_dom_equal "<input type=\"hidden\" id=\"date_minute\" name=\"date[minute]\" value=\"8\" />\n", select_minute(8, :use_hidden => true)
-  end
-
-  def test_select_minute_with_hidden_and_field_name
-    assert_dom_equal "<input type=\"hidden\" id=\"date_minuto\" name=\"date[minuto]\" value=\"8\" />\n", select_minute(8, :use_hidden => true, :field_name => 'minuto')
-  end
-
-  def test_select_minute_with_html_options
-    expected = %(<select id="date_minute" name="date[minute]" class="selector" accesskey="M">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_minute(Time.mktime(2003, 8, 16, 8, 4, 18), {}, :class => 'selector', :accesskey => 'M')
-
-    #result = select_minute(Time.mktime(2003, 8, 16, 8, 4, 18), {}, :class => 'selector', :accesskey => 'M')
-    #assert result.include?('<select id="date_minute" name="date[minute]"')
-    #assert result.include?('class="selector"')
-    #assert result.include?('accesskey="M"')
-    #assert result.include?('<option value="00">00')
-  end
-
-  def test_select_minute_with_default_prompt
-    expected = %(<select id="date_minute" name="date[minute]">\n)
-    expected << %(<option value="">Minute</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_minute(Time.mktime(2003, 8, 16, 8, 4, 18), :prompt => true)
-  end
-
-  def test_select_minute_with_custom_prompt
-    expected = %(<select id="date_minute" name="date[minute]">\n)
-    expected << %(<option value="">Choose minute</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_minute(Time.mktime(2003, 8, 16, 8, 4, 18), :prompt => 'Choose minute')
-  end
-
-  def test_select_second
-    expected = %(<select id="date_second" name="date[second]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_second(Time.mktime(2003, 8, 16, 8, 4, 18))
-  end
-
-  def test_select_second_with_disabled
-    expected = %(<select id="date_second" name="date[second]" disabled="disabled">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_second(Time.mktime(2003, 8, 16, 8, 4, 18), :disabled => true)
-  end
-
-  def test_select_second_with_field_name_override
-    expected = %(<select id="date_segundo" name="date[segundo]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_second(Time.mktime(2003, 8, 16, 8, 4, 18), :field_name => 'segundo')
-  end
-
-  def test_select_second_with_blank
-    expected = %(<select id="date_second" name="date[second]">\n)
-    expected << %(<option value=""></option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_second(Time.mktime(2003, 8, 16, 8, 4, 18), :include_blank => true)
-  end
-
-  def test_select_second_nil_with_blank
-    expected = %(<select id="date_second" name="date[second]">\n)
-    expected << %(<option value=""></option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_second(nil, :include_blank => true)
-  end
-
-  def test_select_second_with_html_options
-    expected = %(<select id="date_second" name="date[second]" class="selector" accesskey="M">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_second(Time.mktime(2003, 8, 16, 8, 4, 18), {}, :class => 'selector', :accesskey => 'M')
-
-    #result = select_second(Time.mktime(2003, 8, 16, 8, 4, 18), {}, :class => 'selector', :accesskey => 'M')
-    #assert result.include?('<select id="date_second" name="date[second]"')
-    #assert result.include?('class="selector"')
-    #assert result.include?('accesskey="M"')
-    #assert result.include?('<option value="00">00')
-  end
-
-  def test_select_second_with_default_prompt
-    expected = %(<select id="date_second" name="date[second]">\n)
-    expected << %(<option value="">Seconds</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_second(Time.mktime(2003, 8, 16, 8, 4, 18), :prompt => true)
-  end
-
-  def test_select_second_with_custom_prompt
-    expected = %(<select id="date_second" name="date[second]">\n)
-    expected << %(<option value="">Choose seconds</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_second(Time.mktime(2003, 8, 16, 8, 4, 18), :prompt => 'Choose seconds')
-  end
-
-  def test_select_date
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), :start_year => 2003, :end_year => 2005, :prefix => "date[first]")
-  end
-
-  def test_select_date_with_too_big_range_between_start_year_and_end_year
-    assert_raise(ArgumentError) { select_date(Time.mktime(2003, 8, 16), :start_year => 2000, :end_year => 20000, :prefix => "date[first]", :order => [:month, :day, :year]) }
-    assert_raise(ArgumentError) { select_date(Time.mktime(2003, 8, 16), :start_year => Date.today.year - 100.years, :end_year => 2000, :prefix => "date[first]", :order => [:month, :day, :year]) }
-  end
-
-  def test_select_date_can_have_more_then_1000_years_interval_if_forced_via_parameter
-    assert_nothing_raised { select_date(Time.mktime(2003, 8, 16), :start_year => 2000, :end_year => 3100, :max_years_allowed => 2000) }
-  end
-
-  def test_select_date_with_order
-    expected = %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    expected <<  %(<select id="date_first_year" name="date[first][year]">\n)
-    expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), :start_year => 2003, :end_year => 2005, :prefix => "date[first]", :order => [:month, :day, :year])
-  end
-
-  def test_select_date_with_incomplete_order
-    # Since the order is incomplete nothing will be shown
-    expected = %(<input id="date_first_year" name="date[first][year]" type="hidden" value="2003" />\n)
-    expected << %(<input id="date_first_month" name="date[first][month]" type="hidden" value="8" />\n)
-    expected << %(<input id="date_first_day" name="date[first][day]" type="hidden" value="1" />\n)
-
-    assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), :start_year => 2003, :end_year => 2005, :prefix => "date[first]", :order => [:day])
-  end
-
-  def test_select_date_with_disabled
-    expected =  %(<select id="date_first_year" name="date[first][year]" disabled="disabled">\n)
-    expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]" disabled="disabled">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]" disabled="disabled">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), :start_year => 2003, :end_year => 2005, :prefix => "date[first]", :disabled => true)
-  end
-
-  def test_select_date_with_no_start_year
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    (Date.today.year-5).upto(Date.today.year+1) do |y|
-      if y == Date.today.year
-        expected << %(<option value="#{y}" selected="selected">#{y}</option>\n)
-      else
-        expected << %(<option value="#{y}">#{y}</option>\n)
-      end
-    end
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_date(
-      Time.mktime(Date.today.year, 8, 16), :end_year => Date.today.year+1, :prefix => "date[first]"
-    )
-  end
-
-  def test_select_date_with_no_end_year
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    2003.upto(2008) do |y|
-      if y == 2003
-        expected << %(<option value="#{y}" selected="selected">#{y}</option>\n)
-      else
-        expected << %(<option value="#{y}">#{y}</option>\n)
-      end
-    end
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_date(
-      Time.mktime(2003, 8, 16), :start_year => 2003, :prefix => "date[first]"
-    )
-  end
-
-  def test_select_date_with_no_start_or_end_year
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    (Date.today.year-5).upto(Date.today.year+5) do |y|
-      if y == Date.today.year
-        expected << %(<option value="#{y}" selected="selected">#{y}</option>\n)
-      else
-        expected << %(<option value="#{y}">#{y}</option>\n)
-      end
-    end
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_date(
-      Time.mktime(Date.today.year, 8, 16), :prefix => "date[first]"
-    )
-  end
-
-  def test_select_date_with_zero_value
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    expected << %(<option value="2003">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_date(0, :start_year => 2003, :end_year => 2005, :prefix => "date[first]")
-  end
-
-  def test_select_date_with_zero_value_and_no_start_year
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    (Date.today.year-5).upto(Date.today.year+1) { |y| expected << %(<option value="#{y}">#{y}</option>\n) }
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_date(0, :end_year => Date.today.year+1, :prefix => "date[first]")
-  end
-
-  def test_select_date_with_zero_value_and_no_end_year
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    last_year = Time.now.year + 5
-    2003.upto(last_year) { |y| expected << %(<option value="#{y}">#{y}</option>\n) }
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_date(0, :start_year => 2003, :prefix => "date[first]")
-  end
-
-  def test_select_date_with_zero_value_and_no_start_and_end_year
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    (Date.today.year-5).upto(Date.today.year+5) { |y| expected << %(<option value="#{y}">#{y}</option>\n) }
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_date(0, :prefix => "date[first]")
-  end
-
-  def test_select_date_with_nil_value_and_no_start_and_end_year
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    (Date.today.year-5).upto(Date.today.year+5) { |y| expected << %(<option value="#{y}">#{y}</option>\n) }
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_date(nil, :prefix => "date[first]")
-  end
-
-  def test_select_date_with_html_options
-    expected =  %(<select id="date_first_year" name="date[first][year]" class="selector">\n)
-    expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]" class="selector">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]" class="selector">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), {:start_year => 2003, :end_year => 2005, :prefix => "date[first]"}, :class => "selector")
-  end
-
-  def test_select_date_with_separator
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    expected << " / "
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << " / "
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), { :date_separator => " / ", :start_year => 2003, :end_year => 2005, :prefix => "date[first]"})
-  end
-
-  def test_select_date_with_separator_and_discard_day
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    expected << " / "
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<input type="hidden" id="date_first_day" name="date[first][day]" value="1" />\n)
-
-    assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), { :date_separator => " / ", :discard_day => true, :start_year => 2003, :end_year => 2005, :prefix => "date[first]"})
-  end
-
-  def test_select_date_with_separator_discard_month_and_day
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<input type="hidden" id="date_first_month" name="date[first][month]" value="8" />\n)
-    expected << %(<input type="hidden" id="date_first_day" name="date[first][day]" value="1" />\n)
-
-    assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), { :date_separator => " / ", :discard_month => true, :discard_day => true, :start_year => 2003, :end_year => 2005, :prefix => "date[first]"})
-  end
-
-  def test_select_date_with_hidden
-    expected =  %(<input id="date_first_year" name="date[first][year]" type="hidden" value="2003"/>\n)
-    expected << %(<input id="date_first_month" name="date[first][month]" type="hidden" value="8" />\n)
-    expected << %(<input id="date_first_day" name="date[first][day]" type="hidden" value="16" />\n)
-
-    assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), { :prefix => "date[first]", :use_hidden => true })
-    assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), { :date_separator => " / ", :prefix => "date[first]", :use_hidden => true })
-  end
-
-  def test_select_date_with_css_classes_option
-    expected =  %(<select id="date_first_year" name="date[first][year]" class="year">\n)
-    expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]" class="month">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]" class="day">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_date(Time.mktime(2003, 8, 16), {:start_year => 2003, :end_year => 2005, :prefix => "date[first]", :with_css_classes => true})
-  end
-
-  def test_select_datetime
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %(<select id="date_first_hour" name="date[first][hour]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    expected << " : "
-
-    expected << %(<select id="date_first_minute" name="date[first][minute]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_datetime(Time.mktime(2003, 8, 16, 8, 4, 18), :start_year => 2003, :end_year => 2005, :prefix => "date[first]")
-  end
-
-  def test_select_datetime_with_ampm
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %(<select id="date_first_hour" name="date[first][hour]">\n)
-    expected << %(<option value="00">12 AM</option>\n<option value="01">01 AM</option>\n<option value="02">02 AM</option>\n<option value="03">03 AM</option>\n<option value="04">04 AM</option>\n<option value="05">05 AM</option>\n<option value="06">06 AM</option>\n<option value="07">07 AM</option>\n<option value="08" selected="selected">08 AM</option>\n<option value="09">09 AM</option>\n<option value="10">10 AM</option>\n<option value="11">11 AM</option>\n<option value="12">12 PM</option>\n<option value="13">01 PM</option>\n<option value="14">02 PM</option>\n<option value="15">03 PM</option>\n<option value="16">04 PM</option>\n<option value="17">05 PM</option>\n<option value="18">06 PM</option>\n<option value="19">07 PM</option>\n<option value="20">08 PM</option>\n<option value="21">09 PM</option>\n<option value="22">10 PM</option>\n<option value="23">11 PM</option>\n)
-    expected << "</select>\n"
-
-    expected << " : "
-
-    expected << %(<select id="date_first_minute" name="date[first][minute]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_datetime(Time.mktime(2003, 8, 16, 8, 4, 18), :start_year => 2003, :end_year => 2005, :prefix => "date[first]", :ampm => true)
-  end
-
-  def test_select_datetime_with_separators
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %(<select id="date_first_hour" name="date[first][hour]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    expected << " : "
-
-    expected << %(<select id="date_first_minute" name="date[first][minute]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_datetime(Time.mktime(2003, 8, 16, 8, 4, 18), :start_year => 2003, :end_year => 2005, :prefix => "date[first]", :datetime_separator => ' &mdash; ', :time_separator => ' : ')
-  end
-
-  def test_select_datetime_with_nil_value_and_no_start_and_end_year
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    (Date.today.year-5).upto(Date.today.year+5) { |y| expected << %(<option value="#{y}">#{y}</option>\n) }
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %(<select id="date_first_hour" name="date[first][hour]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    expected << " : "
-
-    expected << %(<select id="date_first_minute" name="date[first][minute]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_datetime(nil, :prefix => "date[first]")
-  end
-
-  def test_select_datetime_with_html_options
-    expected =  %(<select id="date_first_year" name="date[first][year]" class="selector">\n)
-    expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-
-    expected << %(<select id="date_first_month" name="date[first][month]" class="selector">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]" class="selector">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %(<select id="date_first_hour" name="date[first][hour]" class="selector">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    expected << " : "
-
-    expected << %(<select id="date_first_minute" name="date[first][minute]" class="selector">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_datetime(Time.mktime(2003, 8, 16, 8, 4, 18), {:start_year => 2003, :end_year => 2005, :prefix => "date[first]"}, :class => 'selector')
-  end
-
-  def test_select_datetime_with_all_separators
-    expected =  %(<select id="date_first_year" name="date[first][year]" class="selector">\n)
-    expected << %(<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    expected << "/"
-
-    expected << %(<select id="date_first_month" name="date[first][month]" class="selector">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << "/"
-
-    expected << %(<select id="date_first_day" name="date[first][day]" class="selector">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    expected << "&mdash;"
-
-    expected << %(<select id="date_first_hour" name="date[first][hour]" class="selector">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    expected << ":"
-
-    expected << %(<select id="date_first_minute" name="date[first][minute]" class="selector">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_datetime(Time.mktime(2003, 8, 16, 8, 4, 18), { :datetime_separator => "&mdash;", :date_separator => "/", :time_separator => ":", :start_year => 2003, :end_year => 2005, :prefix => "date[first]"}, :class => 'selector')
-  end
-
-  def test_select_datetime_should_work_with_date
-    assert_nothing_raised { select_datetime(Date.today) }
-  end
-
-  def test_select_datetime_with_default_prompt
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    expected << %(<option value="">Year</option>\n<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="">Month</option>\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="">Day</option>\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %(<select id="date_first_hour" name="date[first][hour]">\n)
-    expected << %(<option value="">Hour</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    expected << " : "
-
-    expected << %(<select id="date_first_minute" name="date[first][minute]">\n)
-    expected << %(<option value="">Minute</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_datetime(Time.mktime(2003, 8, 16, 8, 4, 18), :start_year => 2003, :end_year => 2005,
-                                               :prefix => "date[first]", :prompt => true)
-  end
-
-  def test_select_datetime_with_custom_prompt
-
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    expected << %(<option value="">Choose year</option>\n<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="">Choose month</option>\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="">Choose day</option>\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %(<select id="date_first_hour" name="date[first][hour]">\n)
-    expected << %(<option value="">Choose hour</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    expected << " : "
-
-    expected << %(<select id="date_first_minute" name="date[first][minute]">\n)
-    expected << %(<option value="">Choose minute</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_datetime(Time.mktime(2003, 8, 16, 8, 4, 18), :start_year => 2003, :end_year => 2005, :prefix => "date[first]",
-      :prompt => {:day => 'Choose day', :month => 'Choose month', :year => 'Choose year', :hour => 'Choose hour', :minute => 'Choose minute'})
-  end
-
-  def test_select_datetime_with_custom_hours
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    expected << %(<option value="">Choose year</option>\n<option value="2003" selected="selected">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="">Choose month</option>\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8" selected="selected">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="">Choose day</option>\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %(<select id="date_first_hour" name="date[first][hour]">\n)
-    expected << %(<option value="">Choose hour</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n)
-    expected << "</select>\n"
-
-    expected << " : "
-
-    expected << %(<select id="date_first_minute" name="date[first][minute]">\n)
-    expected << %(<option value="">Choose minute</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_datetime(Time.mktime(2003, 8, 16, 8, 4, 18), :start_year => 2003, :end_year => 2005, :start_hour => 1, :end_hour => 9, :prefix => "date[first]",
-      :prompt => {:day => 'Choose day', :month => 'Choose month', :year => 'Choose year', :hour => 'Choose hour', :minute => 'Choose minute'})
-  end
-
-  def test_select_datetime_with_hidden
-    expected =  %(<input id="date_first_year" name="date[first][year]" type="hidden" value="2003" />\n)
-    expected << %(<input id="date_first_month" name="date[first][month]" type="hidden" value="8" />\n)
-    expected << %(<input id="date_first_day" name="date[first][day]" type="hidden" value="16" />\n)
-    expected << %(<input id="date_first_hour" name="date[first][hour]" type="hidden" value="8" />\n)
-    expected << %(<input id="date_first_minute" name="date[first][minute]" type="hidden" value="4" />\n)
-
-    assert_dom_equal expected, select_datetime(Time.mktime(2003, 8, 16, 8, 4, 18), :prefix => "date[first]", :use_hidden => true)
-    assert_dom_equal expected, select_datetime(Time.mktime(2003, 8, 16, 8, 4, 18), :datetime_separator => "&mdash;", :date_separator => "/",
-      :time_separator => ":", :prefix => "date[first]", :use_hidden => true)
-  end
-
-  def test_select_time
-    expected = %(<input name="date[year]" id="date_year" value="2003" type="hidden" />\n)
-    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" />\n)
-    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" />\n)
-
-    expected << %(<select id="date_hour" name="date[hour]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    expected << " : "
-
-    expected << %(<select id="date_minute" name="date[minute]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_time(Time.mktime(2003, 8, 16, 8, 4, 18))
-    assert_dom_equal expected, select_time(Time.mktime(2003, 8, 16, 8, 4, 18), :include_seconds => false)
-  end
-
-  def test_select_time_with_ampm
-    expected = %(<input name="date[year]" id="date_year" value="2003" type="hidden" />\n)
-    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" />\n)
-    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" />\n)
-
-    expected << %(<select id="date_hour" name="date[hour]">\n)
-    expected << %(<option value="00">12 AM</option>\n<option value="01">01 AM</option>\n<option value="02">02 AM</option>\n<option value="03">03 AM</option>\n<option value="04">04 AM</option>\n<option value="05">05 AM</option>\n<option value="06">06 AM</option>\n<option value="07">07 AM</option>\n<option value="08" selected="selected">08 AM</option>\n<option value="09">09 AM</option>\n<option value="10">10 AM</option>\n<option value="11">11 AM</option>\n<option value="12">12 PM</option>\n<option value="13">01 PM</option>\n<option value="14">02 PM</option>\n<option value="15">03 PM</option>\n<option value="16">04 PM</option>\n<option value="17">05 PM</option>\n<option value="18">06 PM</option>\n<option value="19">07 PM</option>\n<option value="20">08 PM</option>\n<option value="21">09 PM</option>\n<option value="22">10 PM</option>\n<option value="23">11 PM</option>\n)
-    expected << "</select>\n"
-
-    expected << " : "
-
-    expected << %(<select id="date_minute" name="date[minute]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_time(Time.mktime(2003, 8, 16, 8, 4, 18), :include_seconds => false, :ampm => true)
-  end
-
-  def test_select_time_with_separator
-    expected = %(<input name="date[year]" id="date_year" value="2003" type="hidden" />\n)
-    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" />\n)
-    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" />\n)
-    expected << %(<select id="date_hour" name="date[hour]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    expected << " : "
-
-    expected << %(<select id="date_minute" name="date[minute]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_time(Time.mktime(2003, 8, 16, 8, 4, 18), :time_separator => ' : ')
-    assert_dom_equal expected, select_time(Time.mktime(2003, 8, 16, 8, 4, 18), :time_separator => ' : ', :include_seconds => false)
-  end
-
-  def test_select_time_with_seconds
-    expected = %(<input name="date[year]" id="date_year" value="2003" type="hidden" />\n)
-    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" />\n)
-    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" />\n)
-
-    expected << %(<select id="date_hour" name="date[hour]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    expected << ' : '
-
-    expected << %(<select id="date_minute" name="date[minute]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    expected << ' : '
-
-    expected << %(<select id="date_second" name="date[second]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_time(Time.mktime(2003, 8, 16, 8, 4, 18), :include_seconds => true)
-  end
-
-  def test_select_time_with_seconds_and_separator
-    expected = %(<input name="date[year]" id="date_year" value="2003" type="hidden" />\n)
-    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" />\n)
-    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" />\n)
-
-    expected << %(<select id="date_hour" name="date[hour]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    expected << " : "
-
-    expected << %(<select id="date_minute" name="date[minute]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    expected << " : "
-
-    expected << %(<select id="date_second" name="date[second]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_time(Time.mktime(2003, 8, 16, 8, 4, 18), :include_seconds => true, :time_separator => ' : ')
-  end
-
-  def test_select_time_with_html_options
-    expected = %(<input name="date[year]" id="date_year" value="2003" type="hidden" />\n)
-    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" />\n)
-    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" />\n)
-
-    expected << %(<select id="date_hour" name="date[hour]" class="selector">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    expected << " : "
-
-    expected << %(<select id="date_minute" name="date[minute]" class="selector">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_time(Time.mktime(2003, 8, 16, 8, 4, 18), {}, :class => 'selector')
-    assert_dom_equal expected, select_time(Time.mktime(2003, 8, 16, 8, 4, 18), {:include_seconds => false}, :class => 'selector')
-  end
-
-  def test_select_time_should_work_with_date
-    assert_nothing_raised { select_time(Date.today) }
-  end
-
-  def test_select_time_with_default_prompt
-    expected = %(<input name="date[year]" id="date_year" value="2003" type="hidden" />\n)
-    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" />\n)
-    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" />\n)
-
-    expected << %(<select id="date_hour" name="date[hour]">\n)
-    expected << %(<option value="">Hour</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    expected << " : "
-
-    expected << %(<select id="date_minute" name="date[minute]">\n)
-    expected << %(<option value="">Minute</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    expected << " : "
-
-    expected << %(<select id="date_second" name="date[second]">\n)
-    expected << %(<option value="">Seconds</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_time(Time.mktime(2003, 8, 16, 8, 4, 18), :include_seconds => true, :prompt => true)
-  end
-
-  def test_select_time_with_custom_prompt
-    expected = %(<input name="date[year]" id="date_year" value="2003" type="hidden" />\n)
-    expected << %(<input name="date[month]" id="date_month" value="8" type="hidden" />\n)
-    expected << %(<input name="date[day]" id="date_day" value="16" type="hidden" />\n)
-
-    expected << %(<select id="date_hour" name="date[hour]">\n)
-    expected << %(<option value="">Choose hour</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08" selected="selected">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    expected << " : "
-
-    expected << %(<select id="date_minute" name="date[minute]">\n)
-    expected << %(<option value="">Choose minute</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04" selected="selected">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    expected << " : "
-
-    expected << %(<select id="date_second" name="date[second]">\n)
-    expected << %(<option value="">Choose seconds</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18" selected="selected">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_time(Time.mktime(2003, 8, 16, 8, 4, 18), :prompt => true, :include_seconds => true,
-      :prompt => {:hour => 'Choose hour', :minute => 'Choose minute', :second => 'Choose seconds'})
-  end
-
-  def test_select_time_with_hidden
-    expected =  %(<input id="date_first_year" name="date[first][year]" type="hidden" value="2003" />\n)
-    expected << %(<input id="date_first_month" name="date[first][month]" type="hidden" value="8" />\n)
-    expected << %(<input id="date_first_day" name="date[first][day]" type="hidden" value="16" />\n)
-    expected << %(<input id="date_first_hour" name="date[first][hour]" type="hidden" value="8" />\n)
-    expected << %(<input id="date_first_minute" name="date[first][minute]" type="hidden" value="4" />\n)
-
-    assert_dom_equal expected, select_time(Time.mktime(2003, 8, 16, 8, 4, 18), :prefix => "date[first]", :use_hidden => true)
-    assert_dom_equal expected, select_time(Time.mktime(2003, 8, 16, 8, 4, 18), :time_separator => ":", :prefix => "date[first]", :use_hidden => true)
-  end
-
-  def test_date_select
-    @post = Post.new
-    @post.written_on = Date.new(2004, 6, 15)
-
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
-    expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
-    expected << %{<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15" selected="selected">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-
-    expected << "</select>\n"
-
-    assert_dom_equal expected, date_select("post", "written_on")
-  end
-
-  def test_date_select_with_selected
-    @post = Post.new
-    @post.written_on = Date.new(2004, 6, 15)
-
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
-    expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option selected="selected" value="2004">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7" selected="selected">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
-    expected << %{<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10" selected="selected">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-
-    expected << "</select>\n"
-
-    assert_dom_equal expected, date_select("post", "written_on", :selected => Date.new(2004, 07, 10))
-  end
-
-  def test_date_select_with_selected_nil
-    @post = Post.new
-    @post.written_on = Date.new(2004, 6, 15)
-
-    expected = '<input id="post_written_on_1i" name="post[written_on(1i)]" type="hidden" value="1"/>' + "\n"
-
-    expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
-    expected << %{<option value=""></option>\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
-    expected << %{<option value=""></option>\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-
-    expected << "</select>\n"
-
-    assert_dom_equal expected, date_select("post", "written_on", include_blank: true, discard_year: true, selected: nil)
-  end
-
-  def test_date_select_without_day
-    @post = Post.new
-    @post.written_on = Date.new(2004, 6, 15)
-
-    expected = "<input type=\"hidden\" id=\"post_written_on_3i\" name=\"post[written_on(3i)]\" value=\"1\" />\n"
-
-    expected <<  %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
-    expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    assert_dom_equal expected, date_select("post", "written_on", :order => [ :month, :year ])
-  end
-
-  def test_date_select_without_day_and_month
-    @post = Post.new
-    @post.written_on = Date.new(2004, 2, 29)
-
-    expected = "<input type=\"hidden\" id=\"post_written_on_2i\" name=\"post[written_on(2i)]\" value=\"2\" />\n"
-    expected << "<input type=\"hidden\" id=\"post_written_on_3i\" name=\"post[written_on(3i)]\" value=\"1\" />\n"
-
-    expected << %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
-    expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    assert_dom_equal expected, date_select("post", "written_on", :order => [ :year ])
-  end
-
-  def test_date_select_without_day_with_separator
-    @post = Post.new
-    @post.written_on = Date.new(2004, 6, 15)
-
-    expected = "<input type=\"hidden\" id=\"post_written_on_3i\" name=\"post[written_on(3i)]\" value=\"1\" />\n"
-
-    expected <<  %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << "/"
-
-    expected << %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
-    expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    assert_dom_equal expected, date_select("post", "written_on", :date_separator => '/', :order => [ :month, :year ])
-  end
-
-  def test_date_select_without_day_and_with_disabled_html_option
-    @post = Post.new
-    @post.written_on = Date.new(2004, 6, 15)
-
-    expected = "<input type=\"hidden\" id=\"post_written_on_3i\" disabled=\"disabled\" name=\"post[written_on(3i)]\" value=\"1\" />\n"
-
-    expected <<  %{<select id="post_written_on_2i" disabled="disabled" name="post[written_on(2i)]">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_1i" disabled="disabled" name="post[written_on(1i)]">\n}
-    expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    assert_dom_equal expected, date_select("post", "written_on", { :order => [ :month, :year ] }, :disabled => true)
-  end
-
-  def test_date_select_within_fields_for
-    @post = Post.new
-    @post.written_on = Date.new(2004, 6, 15)
-
-    output_buffer = fields_for :post, @post do |f|
-      concat f.date_select(:written_on)
-    end
-
-    expected = "<select id='post_written_on_1i' name='post[written_on(1i)]'>\n<option value='1999'>1999</option>\n<option value='2000'>2000</option>\n<option value='2001'>2001</option>\n<option value='2002'>2002</option>\n<option value='2003'>2003</option>\n<option selected='selected' value='2004'>2004</option>\n<option value='2005'>2005</option>\n<option value='2006'>2006</option>\n<option value='2007'>2007</option>\n<option value='2008'>2008</option>\n<option value='2009'>2009</option>\n</select>\n"
-    expected << "<select id='post_written_on_2i' name='post[written_on(2i)]'>\n<option value='1'>January</option>\n<option value='2'>February</option>\n<option value='3'>March</option>\n<option value='4'>April</option>\n<option value='5'>May</option>\n<option selected='selected' value='6'>June</option>\n<option value='7'>July</option>\n<option value='8'>August</option>\n<option value='9'>September</option>\n<option value='10'>October</option>\n<option value='11'>November</option>\n<option value='12'>December</option>\n</select>\n"
-    expected << "<select id='post_written_on_3i' name='post[written_on(3i)]'>\n<option value='1'>1</option>\n<option value='2'>2</option>\n<option value='3'>3</option>\n<option value='4'>4</option>\n<option value='5'>5</option>\n<option value='6'>6</option>\n<option value='7'>7</option>\n<option value='8'>8</option>\n<option value='9'>9</option>\n<option value='10'>10</option>\n<option value='11'>11</option>\n<option value='12'>12</option>\n<option value='13'>13</option>\n<option value='14'>14</option>\n<option selected='selected' value='15'>15</option>\n<option value='16'>16</option>\n<option value='17'>17</option>\n<option value='18'>18</option>\n<option value='19'>19</option>\n<option value='20'>20</option>\n<option value='21'>21</option>\n<option value='22'>22</option>\n<option value='23'>23</option>\n<option value='24'>24</option>\n<option value='25'>25</option>\n<option value='26'>26</option>\n<option value='27'>27</option>\n<option value='28'>28</option>\n<option value='29'>29</option>\n<option value='30'>30</option>\n<option value='31'>31</option>\n</select>\n"
-
-    assert_dom_equal(expected, output_buffer)
-  end
-
-  def test_date_select_within_fields_for_with_index
-    @post = Post.new
-    @post.written_on = Date.new(2004, 6, 15)
-    id = 27
-
-    output_buffer = fields_for :post, @post, :index => id do |f|
-      concat f.date_select(:written_on)
-    end
-
-    expected = "<select id='post_#{id}_written_on_1i' name='post[#{id}][written_on(1i)]'>\n<option value='1999'>1999</option>\n<option value='2000'>2000</option>\n<option value='2001'>2001</option>\n<option value='2002'>2002</option>\n<option value='2003'>2003</option>\n<option selected='selected' value='2004'>2004</option>\n<option value='2005'>2005</option>\n<option value='2006'>2006</option>\n<option value='2007'>2007</option>\n<option value='2008'>2008</option>\n<option value='2009'>2009</option>\n</select>\n"
-    expected << "<select id='post_#{id}_written_on_2i' name='post[#{id}][written_on(2i)]'>\n<option value='1'>January</option>\n<option value='2'>February</option>\n<option value='3'>March</option>\n<option value='4'>April</option>\n<option value='5'>May</option>\n<option selected='selected' value='6'>June</option>\n<option value='7'>July</option>\n<option value='8'>August</option>\n<option value='9'>September</option>\n<option value='10'>October</option>\n<option value='11'>November</option>\n<option value='12'>December</option>\n</select>\n"
-    expected << "<select id='post_#{id}_written_on_3i' name='post[#{id}][written_on(3i)]'>\n<option value='1'>1</option>\n<option value='2'>2</option>\n<option value='3'>3</option>\n<option value='4'>4</option>\n<option value='5'>5</option>\n<option value='6'>6</option>\n<option value='7'>7</option>\n<option value='8'>8</option>\n<option value='9'>9</option>\n<option value='10'>10</option>\n<option value='11'>11</option>\n<option value='12'>12</option>\n<option value='13'>13</option>\n<option value='14'>14</option>\n<option selected='selected' value='15'>15</option>\n<option value='16'>16</option>\n<option value='17'>17</option>\n<option value='18'>18</option>\n<option value='19'>19</option>\n<option value='20'>20</option>\n<option value='21'>21</option>\n<option value='22'>22</option>\n<option value='23'>23</option>\n<option value='24'>24</option>\n<option value='25'>25</option>\n<option value='26'>26</option>\n<option value='27'>27</option>\n<option value='28'>28</option>\n<option value='29'>29</option>\n<option value='30'>30</option>\n<option value='31'>31</option>\n</select>\n"
-
-    assert_dom_equal(expected, output_buffer)
-  end
-
-  def test_date_select_within_fields_for_with_blank_index
-    @post = Post.new
-    @post.written_on = Date.new(2004, 6, 15)
-    id = nil
-
-    output_buffer = fields_for :post, @post, :index => id do |f|
-      concat f.date_select(:written_on)
-    end
-
-    expected = "<select id='post_#{id}_written_on_1i' name='post[#{id}][written_on(1i)]'>\n<option value='1999'>1999</option>\n<option value='2000'>2000</option>\n<option value='2001'>2001</option>\n<option value='2002'>2002</option>\n<option value='2003'>2003</option>\n<option selected='selected' value='2004'>2004</option>\n<option value='2005'>2005</option>\n<option value='2006'>2006</option>\n<option value='2007'>2007</option>\n<option value='2008'>2008</option>\n<option value='2009'>2009</option>\n</select>\n"
-    expected << "<select id='post_#{id}_written_on_2i' name='post[#{id}][written_on(2i)]'>\n<option value='1'>January</option>\n<option value='2'>February</option>\n<option value='3'>March</option>\n<option value='4'>April</option>\n<option value='5'>May</option>\n<option selected='selected' value='6'>June</option>\n<option value='7'>July</option>\n<option value='8'>August</option>\n<option value='9'>September</option>\n<option value='10'>October</option>\n<option value='11'>November</option>\n<option value='12'>December</option>\n</select>\n"
-    expected << "<select id='post_#{id}_written_on_3i' name='post[#{id}][written_on(3i)]'>\n<option value='1'>1</option>\n<option value='2'>2</option>\n<option value='3'>3</option>\n<option value='4'>4</option>\n<option value='5'>5</option>\n<option value='6'>6</option>\n<option value='7'>7</option>\n<option value='8'>8</option>\n<option value='9'>9</option>\n<option value='10'>10</option>\n<option value='11'>11</option>\n<option value='12'>12</option>\n<option value='13'>13</option>\n<option value='14'>14</option>\n<option selected='selected' value='15'>15</option>\n<option value='16'>16</option>\n<option value='17'>17</option>\n<option value='18'>18</option>\n<option value='19'>19</option>\n<option value='20'>20</option>\n<option value='21'>21</option>\n<option value='22'>22</option>\n<option value='23'>23</option>\n<option value='24'>24</option>\n<option value='25'>25</option>\n<option value='26'>26</option>\n<option value='27'>27</option>\n<option value='28'>28</option>\n<option value='29'>29</option>\n<option value='30'>30</option>\n<option value='31'>31</option>\n</select>\n"
-
-    assert_dom_equal(expected, output_buffer)
-  end
-
-  def test_date_select_with_index
-    @post = Post.new
-    @post.written_on = Date.new(2004, 6, 15)
-    id = 456
-
-    expected = %{<select id="post_456_written_on_1i" name="post[#{id}][written_on(1i)]">\n}
-    expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_456_written_on_2i" name="post[#{id}][written_on(2i)]">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_456_written_on_3i" name="post[#{id}][written_on(3i)]">\n}
-    expected << %{<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15" selected="selected">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-    expected << "</select>\n"
-
-    assert_dom_equal expected, date_select("post", "written_on", :index => id)
-  end
-
-  def test_date_select_with_auto_index
-    @post = Post.new
-    @post.written_on = Date.new(2004, 6, 15)
-    id = 123
-
-    expected = %{<select id="post_123_written_on_1i" name="post[#{id}][written_on(1i)]">\n}
-    expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_123_written_on_2i" name="post[#{id}][written_on(2i)]">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_123_written_on_3i" name="post[#{id}][written_on(3i)]">\n}
-    expected << %{<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15" selected="selected">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-    expected << "</select>\n"
-
-    assert_dom_equal expected, date_select("post[]", "written_on")
-  end
-
-  def test_date_select_with_different_order
-    @post = Post.new
-    @post.written_on = Date.new(2004, 6, 15)
-
-    expected =  %{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
-    1.upto(31) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 15}>#{i}</option>\n) }
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
-    1.upto(12) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 6}>#{Date::MONTHNAMES[i]}</option>\n) }
-    expected << "</select>\n"
-
-    expected <<  %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
-    1999.upto(2009) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 2004}>#{i}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, date_select("post", "written_on", :order => [:day, :month, :year])
-  end
-
-  def test_date_select_with_nil
-    @post = Post.new
-
-    start_year = Time.now.year-5
-    end_year   = Time.now.year+5
-    expected =   %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
-    start_year.upto(end_year) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == Time.now.year}>#{i}</option>\n) }
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
-    1.upto(12) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == Time.now.month}>#{Date::MONTHNAMES[i]}</option>\n) }
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
-    1.upto(31) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == Time.now.day}>#{i}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, date_select("post", "written_on")
-  end
-
-  def test_date_select_with_nil_and_blank
-    @post = Post.new
-
-    start_year = Time.now.year-5
-    end_year   = Time.now.year+5
-    expected =   %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
-    expected << "<option value=\"\"></option>\n"
-    start_year.upto(end_year) { |i| expected << %(<option value="#{i}">#{i}</option>\n) }
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
-    expected << "<option value=\"\"></option>\n"
-    1.upto(12) { |i| expected << %(<option value="#{i}">#{Date::MONTHNAMES[i]}</option>\n) }
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
-    expected << "<option value=\"\"></option>\n"
-    1.upto(31) { |i| expected << %(<option value="#{i}">#{i}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, date_select("post", "written_on", :include_blank => true)
-  end
-
-  def test_date_select_with_nil_and_blank_and_order
-    @post = Post.new
-
-    start_year = Time.now.year-5
-    end_year   = Time.now.year+5
-
-    expected = '<input name="post[written_on(3i)]" type="hidden" id="post_written_on_3i" value="1"/>' + "\n"
-    expected <<   %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
-    expected << "<option value=\"\"></option>\n"
-    start_year.upto(end_year) { |i| expected << %(<option value="#{i}">#{i}</option>\n) }
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
-    expected << "<option value=\"\"></option>\n"
-    1.upto(12) { |i| expected << %(<option value="#{i}">#{Date::MONTHNAMES[i]}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, date_select("post", "written_on", :order=>[:year, :month], :include_blank=>true)
-  end
-
-  def test_date_select_with_nil_and_blank_and_discard_month
-    @post = Post.new
-
-    start_year = Time.now.year-5
-    end_year   = Time.now.year+5
-
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
-    expected << "<option value=\"\"></option>\n"
-    start_year.upto(end_year) { |i| expected << %(<option value="#{i}">#{i}</option>\n) }
-    expected << "</select>\n"
-    expected << '<input name="post[written_on(2i)]" type="hidden" id="post_written_on_2i" value="1"/>' + "\n"
-    expected << '<input name="post[written_on(3i)]" type="hidden" id="post_written_on_3i" value="1"/>' + "\n"
-
-    assert_dom_equal expected, date_select("post", "written_on", :discard_month => true, :include_blank=>true)
-  end
-
-  def test_date_select_with_nil_and_blank_and_discard_year
-    @post = Post.new
-
-    expected = '<input id="post_written_on_1i" name="post[written_on(1i)]" type="hidden" value="1" />' + "\n"
-
-    expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
-    expected << "<option value=\"\"></option>\n"
-    1.upto(12) { |i| expected << %(<option value="#{i}">#{Date::MONTHNAMES[i]}</option>\n) }
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
-    expected << "<option value=\"\"></option>\n"
-    1.upto(31) { |i| expected << %(<option value="#{i}">#{i}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, date_select("post", "written_on", :discard_year => true, :include_blank=>true)
-  end
-
-  def test_date_select_cant_override_discard_hour
-    @post = Post.new
-    @post.written_on = Date.new(2004, 6, 15)
-
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
-    expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
-    expected << %{<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15" selected="selected">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-    expected << "</select>\n"
-
-    assert_dom_equal expected, date_select("post", "written_on", :discard_hour => false)
-  end
-
-  def test_date_select_with_html_options
-    @post = Post.new
-    @post.written_on = Date.new(2004, 6, 15)
-
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]" class="selector">\n}
-    expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]" class="selector">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_3i" name="post[written_on(3i)]" class="selector">\n}
-    expected << %{<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15" selected="selected">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-
-    expected << "</select>\n"
-
-    assert_dom_equal expected, date_select("post", "written_on", {}, :class => 'selector')
-  end
-
-  def test_date_select_with_html_options_within_fields_for
-    @post = Post.new
-    @post.written_on = Date.new(2004, 6, 15)
-
-    output_buffer = fields_for :post, @post do |f|
-      concat f.date_select(:written_on, {}, :class => 'selector')
-    end
-
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]" class="selector">\n}
-    expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]" class="selector">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_3i" name="post[written_on(3i)]" class="selector">\n}
-    expected << %{<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15" selected="selected">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-
-    expected << "</select>\n"
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_date_select_with_separator
-    @post = Post.new
-    @post.written_on = Date.new(2004, 6, 15)
-
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
-    expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    expected << " / "
-
-    expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << " / "
-
-    expected << %{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
-    expected << %{<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15" selected="selected">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-
-    expected << "</select>\n"
-
-    assert_dom_equal expected, date_select("post", "written_on", { :date_separator => " / " })
-  end
-
-  def test_date_select_with_separator_and_order
-    @post = Post.new
-    @post.written_on = Date.new(2004, 6, 15)
-
-    expected = %{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
-    expected << %{<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15" selected="selected">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-    expected << "</select>\n"
-
-    expected << " / "
-
-    expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << " / "
-
-    expected << %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
-    expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    assert_dom_equal expected, date_select("post", "written_on", { :order => [:day, :month, :year], :date_separator => " / " })
-  end
-
-  def test_date_select_with_separator_and_order_and_year_discarded
-    @post = Post.new
-    @post.written_on = Date.new(2004, 6, 15)
-
-    expected = %{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
-    expected << %{<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15" selected="selected">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-    expected << "</select>\n"
-
-    expected << " / "
-
-    expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-    expected << %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" />\n}
-
-    assert_dom_equal expected, date_select("post", "written_on", { :order => [:day, :month, :year], :discard_year => true, :date_separator => " / " })
-  end
-
-  def test_date_select_with_default_prompt
-    @post = Post.new
-    @post.written_on = Date.new(2004, 6, 15)
-
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
-    expected << %{<option value="">Year</option>\n<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
-    expected << %{<option value="">Month</option>\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
-    expected << %{<option value="">Day</option>\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15" selected="selected">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-
-    expected << "</select>\n"
-
-    assert_dom_equal expected, date_select("post", "written_on", :prompt => true)
-  end
-
-  def test_date_select_with_custom_prompt
-    @post = Post.new
-    @post.written_on = Date.new(2004, 6, 15)
-
-    expected = %{<select id="post_written_on_1i" name="post[written_on(1i)]">\n}
-    expected << %{<option value="">Choose year</option>\n<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_2i" name="post[written_on(2i)]">\n}
-    expected << %{<option value="">Choose month</option>\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_written_on_3i" name="post[written_on(3i)]">\n}
-    expected << %{<option value="">Choose day</option>\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15" selected="selected">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-
-    expected << "</select>\n"
-
-    assert_dom_equal expected, date_select("post", "written_on", :prompt => {:year => 'Choose year', :month => 'Choose month', :day => 'Choose day'})
-  end
-
-  def test_time_select
-    @post = Post.new
-    @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
-
-    expected = %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" />\n}
-
-    expected << %(<select id="post_written_on_4i" name="post[written_on(4i)]">\n)
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << " : "
-    expected << %(<select id="post_written_on_5i" name="post[written_on(5i)]">\n)
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 16}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, time_select("post", "written_on")
-  end
-
-  def test_time_select_with_selected
-    @post = Post.new
-    @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
-
-    expected = %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" />\n}
-
-    expected << %(<select id="post_written_on_4i" name="post[written_on(4i)]">\n)
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 12}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << " : "
-    expected << %(<select id="post_written_on_5i" name="post[written_on(5i)]">\n)
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 20}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, time_select("post", "written_on", selected: Time.local(2004, 6, 15, 12, 20, 30))
-  end
-
-  def test_time_select_with_selected_nil
-    @post = Post.new
-    @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
-
-    expected = %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="1" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="1" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="1" />\n}
-
-    expected << %(<select id="post_written_on_4i" name="post[written_on(4i)]">\n)
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}">#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << " : "
-    expected << %(<select id="post_written_on_5i" name="post[written_on(5i)]">\n)
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}">#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, time_select("post", "written_on", discard_year: true, discard_month: true, discard_day: true, selected: nil)
-  end
-
-  def test_time_select_without_date_hidden_fields
-    @post = Post.new
-    @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
-
-    expected = %(<select id="post_written_on_4i" name="post[written_on(4i)]">\n)
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << " : "
-    expected << %(<select id="post_written_on_5i" name="post[written_on(5i)]">\n)
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 16}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, time_select("post", "written_on", :ignore_date => true)
-  end
-
-  def test_time_select_with_seconds
-    @post = Post.new
-    @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
-
-    expected = %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" />\n}
-
-    expected << %(<select id="post_written_on_4i" name="post[written_on(4i)]">\n)
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << " : "
-    expected << %(<select id="post_written_on_5i" name="post[written_on(5i)]">\n)
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 16}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << " : "
-    expected << %(<select id="post_written_on_6i" name="post[written_on(6i)]">\n)
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 35}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, time_select("post", "written_on", :include_seconds => true)
-  end
-
-  def test_time_select_with_html_options
-    @post = Post.new
-    @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
-
-    expected = %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" />\n}
-
-    expected << %(<select id="post_written_on_4i" name="post[written_on(4i)]" class="selector">\n)
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << " : "
-    expected << %(<select id="post_written_on_5i" name="post[written_on(5i)]" class="selector">\n)
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 16}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, time_select("post", "written_on", {}, :class => 'selector')
-  end
-
-  def test_time_select_with_html_options_within_fields_for
-    @post = Post.new
-    @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
-
-    output_buffer = fields_for :post, @post do |f|
-      concat f.time_select(:written_on, {}, :class => 'selector')
-    end
-
-    expected = %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" />\n}
-
-    expected << %(<select id="post_written_on_4i" name="post[written_on(4i)]" class="selector">\n)
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << " : "
-    expected << %(<select id="post_written_on_5i" name="post[written_on(5i)]" class="selector">\n)
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 16}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_time_select_with_separator
-    @post = Post.new
-    @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
-
-    expected = %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" />\n}
-
-    expected << %(<select id="post_written_on_4i" name="post[written_on(4i)]">\n)
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    expected << " - "
-
-    expected << %(<select id="post_written_on_5i" name="post[written_on(5i)]">\n)
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 16}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    expected << " - "
-
-    expected << %(<select id="post_written_on_6i" name="post[written_on(6i)]">\n)
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 35}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, time_select("post", "written_on", { :time_separator => " - ", :include_seconds => true })
-  end
-
-  def test_time_select_with_default_prompt
-    @post = Post.new
-    @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
-
-    expected = %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" />\n}
-
-    expected << %(<select id="post_written_on_4i" name="post[written_on(4i)]">\n)
-    expected << %(<option value="">Hour</option>\n)
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << " : "
-    expected << %(<select id="post_written_on_5i" name="post[written_on(5i)]">\n)
-        expected << %(<option value="">Minute</option>\n)
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 16}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, time_select("post", "written_on", :prompt => true)
-  end
-
-  def test_time_select_with_custom_prompt
-    @post = Post.new
-    @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
-
-    expected = %{<input type="hidden" id="post_written_on_1i" name="post[written_on(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" name="post[written_on(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" name="post[written_on(3i)]" value="15" />\n}
-
-    expected << %(<select id="post_written_on_4i" name="post[written_on(4i)]">\n)
-    expected << %(<option value="">Choose hour</option>\n)
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << " : "
-    expected << %(<select id="post_written_on_5i" name="post[written_on(5i)]">\n)
-        expected << %(<option value="">Choose minute</option>\n)
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 16}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, time_select("post", "written_on", :prompt => {:hour => 'Choose hour', :minute => 'Choose minute'})
-  end
-
-  def test_time_select_with_disabled_html_option
-    @post = Post.new
-    @post.written_on = Time.local(2004, 6, 15, 15, 16, 35)
-
-    expected = %{<input type="hidden" id="post_written_on_1i" disabled="disabled" name="post[written_on(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_written_on_2i" disabled="disabled" name="post[written_on(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_written_on_3i" disabled="disabled" name="post[written_on(3i)]" value="15" />\n}
-
-    expected << %(<select id="post_written_on_4i" disabled="disabled" name="post[written_on(4i)]">\n)
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << " : "
-    expected << %(<select id="post_written_on_5i" disabled="disabled" name="post[written_on(5i)]">\n)
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 16}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, time_select("post", "written_on", {}, :disabled => true)
-  end
-
-  def test_datetime_select
-    @post = Post.new
-    @post.updated_at = Time.local(2004, 6, 15, 16, 35)
-
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
-    expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_updated_at_3i" name="post[updated_at(3i)]">\n}
-    expected << %{<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15" selected="selected">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %{<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n}
-    expected << %{<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n}
-    expected << "</select>\n"
-    expected << " : "
-    expected << %{<select id="post_updated_at_5i" name="post[updated_at(5i)]">\n}
-    expected << %{<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35" selected="selected">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n}
-    expected << "</select>\n"
-
-    assert_dom_equal expected, datetime_select("post", "updated_at")
-  end
-
-  def test_datetime_select_with_selected
-    @post = Post.new
-    @post.updated_at = Time.local(2004, 6, 15, 16, 35)
-
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
-    expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3" selected="selected">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_updated_at_3i" name="post[updated_at(3i)]">\n}
-    expected << %{<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10" selected="selected">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %{<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n}
-    expected << %{<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12" selected="selected">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n}
-    expected << "</select>\n"
-    expected << " : "
-    expected << %{<select id="post_updated_at_5i" name="post[updated_at(5i)]">\n}
-    expected << %{<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30" selected="selected">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n}
-    expected << "</select>\n"
-
-    assert_dom_equal expected, datetime_select("post", "updated_at", :selected => Time.local(2004, 3, 10, 12, 30))
-  end
-
-  def test_datetime_select_with_selected_nil
-    @post = Post.new
-    @post.updated_at = Time.local(2004, 6, 15, 16, 35)
-
-    expected = '<input id="post_updated_at_1i" name="post[updated_at(1i)]" type="hidden" value="1"/>' + "\n"
-
-    expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_updated_at_3i" name="post[updated_at(3i)]">\n}
-    expected << %{<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %{<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n}
-    expected << %{<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n}
-    expected << "</select>\n"
-    expected << " : "
-    expected << %{<select id="post_updated_at_5i" name="post[updated_at(5i)]">\n}
-    expected << %{<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n}
-    expected << "</select>\n"
-
-    assert_dom_equal expected, datetime_select("post", "updated_at", discard_year: true, selected: nil)
-  end
-
-  def test_datetime_select_defaults_to_time_zone_now_when_config_time_zone_is_set
-    # The love zone is UTC+0
-    mytz = Class.new(ActiveSupport::TimeZone) {
-      attr_accessor :now
-    }.create('tenderlove', 0)
-
-    now       = Time.mktime(2004, 6, 15, 16, 35, 0)
-    mytz.now  = now
-    Time.zone = mytz
-
-    assert_equal mytz, Time.zone
-
-    @post = Post.new
-
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
-    expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_updated_at_3i" name="post[updated_at(3i)]">\n}
-    expected << %{<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15" selected="selected">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %{<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n}
-    expected << %{<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n}
-    expected << "</select>\n"
-    expected << " : "
-    expected << %{<select id="post_updated_at_5i" name="post[updated_at(5i)]">\n}
-    expected << %{<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35" selected="selected">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n}
-    expected << "</select>\n"
-
-    assert_dom_equal expected, datetime_select("post", "updated_at")
-  ensure
-    Time.zone = nil
-  end
-
-  def test_datetime_select_with_html_options_within_fields_for
-    @post = Post.new
-    @post.updated_at = Time.local(2004, 6, 15, 16, 35)
-
-    output_buffer = fields_for :post, @post do |f|
-      concat f.datetime_select(:updated_at, {}, :class => 'selector')
-    end
-
-    expected = "<select id='post_updated_at_1i' name='post[updated_at(1i)]' class='selector'>\n<option value='1999'>1999</option>\n<option value='2000'>2000</option>\n<option value='2001'>2001</option>\n<option value='2002'>2002</option>\n<option value='2003'>2003</option>\n<option selected='selected' value='2004'>2004</option>\n<option value='2005'>2005</option>\n<option value='2006'>2006</option>\n<option value='2007'>2007</option>\n<option value='2008'>2008</option>\n<option value='2009'>2009</option>\n</select>\n"
-    expected << "<select id='post_updated_at_2i' name='post[updated_at(2i)]' class='selector'>\n<option value='1'>January</option>\n<option value='2'>February</option>\n<option value='3'>March</option>\n<option value='4'>April</option>\n<option value='5'>May</option>\n<option selected='selected' value='6'>June</option>\n<option value='7'>July</option>\n<option value='8'>August</option>\n<option value='9'>September</option>\n<option value='10'>October</option>\n<option value='11'>November</option>\n<option value='12'>December</option>\n</select>\n"
-    expected << "<select id='post_updated_at_3i' name='post[updated_at(3i)]' class='selector'>\n<option value='1'>1</option>\n<option value='2'>2</option>\n<option value='3'>3</option>\n<option value='4'>4</option>\n<option value='5'>5</option>\n<option value='6'>6</option>\n<option value='7'>7</option>\n<option value='8'>8</option>\n<option value='9'>9</option>\n<option value='10'>10</option>\n<option value='11'>11</option>\n<option value='12'>12</option>\n<option value='13'>13</option>\n<option value='14'>14</option>\n<option selected='selected' value='15'>15</option>\n<option value='16'>16</option>\n<option value='17'>17</option>\n<option value='18'>18</option>\n<option value='19'>19</option>\n<option value='20'>20</option>\n<option value='21'>21</option>\n<option value='22'>22</option>\n<option value='23'>23</option>\n<option value='24'>24</option>\n<option value='25'>25</option>\n<option value='26'>26</option>\n<option value='27'>27</option>\n<option value='28'>28</option>\n<option value='29'>29</option>\n<option value='30'>30</option>\n<option value='31'>31</option>\n</select>\n"
-    expected << " &mdash; <select id='post_updated_at_4i' name='post[updated_at(4i)]' class='selector'>\n<option value='00'>00</option>\n<option value='01'>01</option>\n<option value='02'>02</option>\n<option value='03'>03</option>\n<option value='04'>04</option>\n<option value='05'>05</option>\n<option value='06'>06</option>\n<option value='07'>07</option>\n<option value='08'>08</option>\n<option value='09'>09</option>\n<option value='10'>10</option>\n<option value='11'>11</option>\n<option value='12'>12</option>\n<option value='13'>13</option>\n<option value='14'>14</option>\n<option value='15'>15</option>\n<option selected='selected' value='16'>16</option>\n<option value='17'>17</option>\n<option value='18'>18</option>\n<option value='19'>19</option>\n<option value='20'>20</option>\n<option value='21'>21</option>\n<option value='22'>22</option>\n<option value='23'>23</option>\n</select>\n"
-    expected << " : <select id='post_updated_at_5i' name='post[updated_at(5i)]' class='selector'>\n<option value='00'>00</option>\n<option value='01'>01</option>\n<option value='02'>02</option>\n<option value='03'>03</option>\n<option value='04'>04</option>\n<option value='05'>05</option>\n<option value='06'>06</option>\n<option value='07'>07</option>\n<option value='08'>08</option>\n<option value='09'>09</option>\n<option value='10'>10</option>\n<option value='11'>11</option>\n<option value='12'>12</option>\n<option value='13'>13</option>\n<option value='14'>14</option>\n<option value='15'>15</option>\n<option value='16'>16</option>\n<option value='17'>17</option>\n<option value='18'>18</option>\n<option value='19'>19</option>\n<option value='20'>20</option>\n<option value='21'>21</option>\n<option value='22'>22</option>\n<option value='23'>23</option>\n<option value='24'>24</option>\n<option value='25'>25</option>\n<option value='26'>26</option>\n<option value='27'>27</option>\n<option value='28'>28</option>\n<option value='29'>29</option>\n<option value='30'>30</option>\n<option value='31'>31</option>\n<option value='32'>32</option>\n<option value='33'>33</option>\n<option value='34'>34</option>\n<option selected='selected' value='35'>35</option>\n<option value='36'>36</option>\n<option value='37'>37</option>\n<option value='38'>38</option>\n<option value='39'>39</option>\n<option value='40'>40</option>\n<option value='41'>41</option>\n<option value='42'>42</option>\n<option value='43'>43</option>\n<option value='44'>44</option>\n<option value='45'>45</option>\n<option value='46'>46</option>\n<option value='47'>47</option>\n<option value='48'>48</option>\n<option value='49'>49</option>\n<option value='50'>50</option>\n<option value='51'>51</option>\n<option value='52'>52</option>\n<option value='53'>53</option>\n<option value='54'>54</option>\n<option value='55'>55</option>\n<option value='56'>56</option>\n<option value='57'>57</option>\n<option value='58'>58</option>\n<option value='59'>59</option>\n</select>\n"
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_datetime_select_with_separators
-    @post = Post.new
-    @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
-
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
-    expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    expected << " / "
-
-    expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << " / "
-
-    expected << %{<select id="post_updated_at_3i" name="post[updated_at(3i)]">\n}
-    expected << %{<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15" selected="selected">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-    expected << "</select>\n"
-
-    expected << " , "
-
-    expected << %(<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n)
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    expected << " - "
-
-    expected << %(<select id="post_updated_at_5i" name="post[updated_at(5i)]">\n)
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 16}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    expected << " - "
-
-    expected << %(<select id="post_updated_at_6i" name="post[updated_at(6i)]">\n)
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 35}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, datetime_select("post", "updated_at", { :date_separator => " / ", :datetime_separator => " , ", :time_separator => " - ", :include_seconds => true })
-  end
-
-  def test_datetime_select_with_integer
-    @post = Post.new
-    @post.updated_at = 3
-    datetime_select("post", "updated_at")
-  end
-
-  def test_datetime_select_with_infinity # Float
-    @post = Post.new
-    @post.updated_at = (-1.0/0)
-    datetime_select("post", "updated_at")
-  end
-
-  def test_datetime_select_with_default_prompt
-    @post = Post.new
-    @post.updated_at = nil
-
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
-    expected << %{<option value="">Year</option>\n<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
-    expected << %{<option value="">Month</option>\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_updated_at_3i" name="post[updated_at(3i)]">\n}
-    expected << %{<option value="">Day</option>\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %{<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n}
-    expected << %{<option value="">Hour</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n}
-    expected << "</select>\n"
-    expected << " : "
-    expected << %{<select id="post_updated_at_5i" name="post[updated_at(5i)]">\n}
-    expected << %{<option value="">Minute</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n}
-    expected << "</select>\n"
-
-    assert_dom_equal expected, datetime_select("post", "updated_at", :start_year=>1999, :end_year=>2009,  :prompt => true)
-  end
-
-  def test_datetime_select_with_custom_prompt
-    @post = Post.new
-    @post.updated_at = nil
-
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
-    expected << %{<option value="">Choose year</option>\n<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
-    expected << %{<option value="">Choose month</option>\n<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_updated_at_3i" name="post[updated_at(3i)]">\n}
-    expected << %{<option value="">Choose day</option>\n<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %{<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n}
-    expected << %{<option value="">Choose hour</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n}
-    expected << "</select>\n"
-    expected << " : "
-    expected << %{<select id="post_updated_at_5i" name="post[updated_at(5i)]">\n}
-    expected << %{<option value="">Choose minute</option>\n<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n}
-    expected << "</select>\n"
-
-    assert_dom_equal expected, datetime_select("post", "updated_at", :start_year=>1999, :end_year=>2009, :prompt => {:year => 'Choose year', :month => 'Choose month', :day => 'Choose day', :hour => 'Choose hour', :minute => 'Choose minute'})
-  end
-
-  def test_date_select_with_zero_value_and_no_start_year
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    (Date.today.year-5).upto(Date.today.year+1) { |y| expected << %(<option value="#{y}">#{y}</option>\n) }
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_date(0, :end_year => Date.today.year+1, :prefix => "date[first]")
-  end
-
-  def test_date_select_with_zero_value_and_no_end_year
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    last_year = Time.now.year + 5
-    2003.upto(last_year) { |y| expected << %(<option value="#{y}">#{y}</option>\n) }
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_date(0, :start_year => 2003, :prefix => "date[first]")
-  end
-
-  def test_date_select_with_zero_value_and_no_start_and_end_year
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    (Date.today.year-5).upto(Date.today.year+5) { |y| expected << %(<option value="#{y}">#{y}</option>\n) }
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_date(0, :prefix => "date[first]")
-  end
-
-  def test_date_select_with_nil_value_and_no_start_and_end_year
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    (Date.today.year-5).upto(Date.today.year+5) { |y| expected << %(<option value="#{y}">#{y}</option>\n) }
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_date(nil, :prefix => "date[first]")
-  end
-
-  def test_datetime_select_with_nil_value_and_no_start_and_end_year
-    expected =  %(<select id="date_first_year" name="date[first][year]">\n)
-    (Date.today.year-5).upto(Date.today.year+5) { |y| expected << %(<option value="#{y}">#{y}</option>\n) }
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_month" name="date[first][month]">\n)
-    expected << %(<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n)
-    expected << "</select>\n"
-
-    expected << %(<select id="date_first_day" name="date[first][day]">\n)
-    expected << %(<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n)
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %(<select id="date_first_hour" name="date[first][hour]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n)
-    expected << "</select>\n"
-
-    expected << " : "
-
-    expected << %(<select id="date_first_minute" name="date[first][minute]">\n)
-    expected << %(<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n)
-    expected << "</select>\n"
-
-    assert_dom_equal expected, select_datetime(nil, :prefix => "date[first]")
-  end
-
-  def test_datetime_select_with_options_index
-    @post = Post.new
-    @post.updated_at = Time.local(2004, 6, 15, 16, 35)
-    id = 456
-
-    expected = %{<select id="post_456_updated_at_1i" name="post[#{id}][updated_at(1i)]">\n}
-    expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_456_updated_at_2i" name="post[#{id}][updated_at(2i)]">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_456_updated_at_3i" name="post[#{id}][updated_at(3i)]">\n}
-    expected << %{<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15" selected="selected">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %{<select id="post_456_updated_at_4i" name="post[#{id}][updated_at(4i)]">\n}
-    expected << %{<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n}
-    expected << "</select>\n"
-    expected << " : "
-    expected << %{<select id="post_456_updated_at_5i" name="post[#{id}][updated_at(5i)]">\n}
-    expected << %{<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35" selected="selected">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n}
-    expected << "</select>\n"
-
-    assert_dom_equal expected, datetime_select("post", "updated_at", :index => id)
-  end
-
-  def test_datetime_select_within_fields_for_with_options_index
-    @post = Post.new
-    @post.updated_at = Time.local(2004, 6, 15, 16, 35)
-    id = 456
-
-    output_buffer = fields_for :post, @post, :index => id do |f|
-      concat f.datetime_select(:updated_at)
-    end
-
-    expected = %{<select id="post_456_updated_at_1i" name="post[#{id}][updated_at(1i)]">\n}
-    expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_456_updated_at_2i" name="post[#{id}][updated_at(2i)]">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_456_updated_at_3i" name="post[#{id}][updated_at(3i)]">\n}
-    expected << %{<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15" selected="selected">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %{<select id="post_456_updated_at_4i" name="post[#{id}][updated_at(4i)]">\n}
-    expected << %{<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n}
-    expected << "</select>\n"
-    expected << " : "
-    expected << %{<select id="post_456_updated_at_5i" name="post[#{id}][updated_at(5i)]">\n}
-    expected << %{<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35" selected="selected">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n}
-    expected << "</select>\n"
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_datetime_select_with_auto_index
-    @post = Post.new
-    @post.updated_at = Time.local(2004, 6, 15, 16, 35)
-    id = @post.id
-
-    expected = %{<select id="post_123_updated_at_1i" name="post[#{id}][updated_at(1i)]">\n}
-    expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_123_updated_at_2i" name="post[#{id}][updated_at(2i)]">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_123_updated_at_3i" name="post[#{id}][updated_at(3i)]">\n}
-    expected << %{<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15" selected="selected">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %{<select id="post_123_updated_at_4i" name="post[#{id}][updated_at(4i)]">\n}
-    expected << %{<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n}
-    expected << "</select>\n"
-    expected << " : "
-    expected << %{<select id="post_123_updated_at_5i" name="post[#{id}][updated_at(5i)]">\n}
-    expected << %{<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35" selected="selected">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n}
-    expected << "</select>\n"
-
-    assert_dom_equal expected, datetime_select("post[]", "updated_at")
-  end
-
-  def test_datetime_select_with_seconds
-    @post = Post.new
-    @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
-
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
-    1999.upto(2009) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 2004}>#{i}</option>\n) }
-    expected << "</select>\n"
-    expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
-    1.upto(12) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 6}>#{Date::MONTHNAMES[i]}</option>\n) }
-    expected << "</select>\n"
-    expected << %{<select id="post_updated_at_3i" name="post[updated_at(3i)]">\n}
-    1.upto(31) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 15}>#{i}</option>\n) }
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %{<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n}
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << " : "
-    expected << %{<select id="post_updated_at_5i" name="post[updated_at(5i)]">\n}
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 16}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << " : "
-    expected << %{<select id="post_updated_at_6i" name="post[updated_at(6i)]">\n}
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 35}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, datetime_select("post", "updated_at", :include_seconds => true)
-  end
-
-  def test_datetime_select_discard_year
-    @post = Post.new
-    @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
-
-    expected = %{<input type="hidden" id="post_updated_at_1i" name="post[updated_at(1i)]" value="2004" />\n}
-    expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
-    1.upto(12) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 6}>#{Date::MONTHNAMES[i]}</option>\n) }
-    expected << "</select>\n"
-    expected << %{<select id="post_updated_at_3i" name="post[updated_at(3i)]">\n}
-    1.upto(31) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 15}>#{i}</option>\n) }
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %{<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n}
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << " : "
-    expected << %{<select id="post_updated_at_5i" name="post[updated_at(5i)]">\n}
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 16}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, datetime_select("post", "updated_at", :discard_year => true)
-  end
-
-  def test_datetime_select_discard_month
-    @post = Post.new
-    @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
-
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
-    1999.upto(2009) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 2004}>#{i}</option>\n) }
-    expected << "</select>\n"
-    expected << %{<input type="hidden" id="post_updated_at_2i" name="post[updated_at(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_updated_at_3i" name="post[updated_at(3i)]" value="1" />\n}
-
-    expected << " &mdash; "
-
-    expected << %{<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n}
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << " : "
-    expected << %{<select id="post_updated_at_5i" name="post[updated_at(5i)]">\n}
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 16}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, datetime_select("post", "updated_at", :discard_month => true)
-  end
-
-  def test_datetime_select_discard_year_and_month
-    @post = Post.new
-    @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
-
-    expected = %{<input type="hidden" id="post_updated_at_1i" name="post[updated_at(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_updated_at_2i" name="post[updated_at(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_updated_at_3i" name="post[updated_at(3i)]" value="1" />\n}
-
-    expected << %{<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n}
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << " : "
-    expected << %{<select id="post_updated_at_5i" name="post[updated_at(5i)]">\n}
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 16}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, datetime_select("post", "updated_at", :discard_year => true, :discard_month => true)
-  end
-
-  def test_datetime_select_discard_year_and_month_with_disabled_html_option
-    @post = Post.new
-    @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
-
-    expected = %{<input type="hidden" id="post_updated_at_1i" disabled="disabled" name="post[updated_at(1i)]" value="2004" />\n}
-    expected << %{<input type="hidden" id="post_updated_at_2i" disabled="disabled" name="post[updated_at(2i)]" value="6" />\n}
-    expected << %{<input type="hidden" id="post_updated_at_3i" disabled="disabled" name="post[updated_at(3i)]" value="1" />\n}
-
-    expected << %{<select id="post_updated_at_4i" disabled="disabled" name="post[updated_at(4i)]">\n}
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << " : "
-    expected << %{<select id="post_updated_at_5i" disabled="disabled" name="post[updated_at(5i)]">\n}
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 16}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, datetime_select("post", "updated_at", { :discard_year => true, :discard_month => true }, :disabled => true)
-  end
-
-  def test_datetime_select_discard_hour
-    @post = Post.new
-    @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
-
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
-    1999.upto(2009) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 2004}>#{i}</option>\n) }
-    expected << "</select>\n"
-    expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
-    1.upto(12) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 6}>#{Date::MONTHNAMES[i]}</option>\n) }
-    expected << "</select>\n"
-    expected << %{<select id="post_updated_at_3i" name="post[updated_at(3i)]">\n}
-    1.upto(31) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 15}>#{i}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, datetime_select("post", "updated_at", :discard_hour => true)
-  end
-
-  def test_datetime_select_discard_minute
-    @post = Post.new
-    @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
-
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
-    1999.upto(2009) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 2004}>#{i}</option>\n) }
-    expected << "</select>\n"
-    expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
-    1.upto(12) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 6}>#{Date::MONTHNAMES[i]}</option>\n) }
-    expected << "</select>\n"
-    expected << %{<select id="post_updated_at_3i" name="post[updated_at(3i)]">\n}
-    1.upto(31) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 15}>#{i}</option>\n) }
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %{<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n}
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << %{<input type="hidden" id="post_updated_at_5i" name="post[updated_at(5i)]" value="16" />\n}
-
-    assert_dom_equal expected, datetime_select("post", "updated_at", :discard_minute => true)
-  end
-
-  def test_datetime_select_disabled_and_discard_minute
-    @post = Post.new
-    @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
-
-    expected = %{<select id="post_updated_at_1i" disabled="disabled" name="post[updated_at(1i)]">\n}
-    1999.upto(2009) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 2004}>#{i}</option>\n) }
-    expected << "</select>\n"
-    expected << %{<select id="post_updated_at_2i" disabled="disabled" name="post[updated_at(2i)]">\n}
-    1.upto(12) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 6}>#{Date::MONTHNAMES[i]}</option>\n) }
-    expected << "</select>\n"
-    expected << %{<select id="post_updated_at_3i" disabled="disabled" name="post[updated_at(3i)]">\n}
-    1.upto(31) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 15}>#{i}</option>\n) }
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %{<select id="post_updated_at_4i" disabled="disabled" name="post[updated_at(4i)]">\n}
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << %{<input type="hidden" id="post_updated_at_5i" disabled="disabled" name="post[updated_at(5i)]" value="16" />\n}
-
-    assert_dom_equal expected, datetime_select("post", "updated_at", :discard_minute => true, :disabled => true)
-  end
-
-  def test_datetime_select_invalid_order
-    @post = Post.new
-    @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
-
-    expected = %{<select id="post_updated_at_3i" name="post[updated_at(3i)]">\n}
-    1.upto(31) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 15}>#{i}</option>\n) }
-    expected << "</select>\n"
-    expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
-    1.upto(12) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 6}>#{Date::MONTHNAMES[i]}</option>\n) }
-    expected << "</select>\n"
-    expected << %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
-    1999.upto(2009) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 2004}>#{i}</option>\n) }
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %{<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n}
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << " : "
-    expected << %{<select id="post_updated_at_5i" name="post[updated_at(5i)]">\n}
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 16}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, datetime_select("post", "updated_at", :order => [:minute, :day, :hour, :month, :year, :second])
-  end
-
-  def test_datetime_select_discard_with_order
-    @post = Post.new
-    @post.updated_at = Time.local(2004, 6, 15, 15, 16, 35)
-
-    expected = %{<input type="hidden" id="post_updated_at_1i" name="post[updated_at(1i)]" value="2004" />\n}
-    expected << %{<select id="post_updated_at_3i" name="post[updated_at(3i)]">\n}
-    1.upto(31) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 15}>#{i}</option>\n) }
-    expected << "</select>\n"
-    expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
-    1.upto(12) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 6}>#{Date::MONTHNAMES[i]}</option>\n) }
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %{<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n}
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << " : "
-    expected << %{<select id="post_updated_at_5i" name="post[updated_at(5i)]">\n}
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 16}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, datetime_select("post", "updated_at", :order => [:day, :month])
-  end
-
-  def test_datetime_select_with_default_value_as_time
-    @post = Post.new
-    @post.updated_at = nil
-
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
-    2001.upto(2011) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 2006}>#{i}</option>\n) }
-    expected << "</select>\n"
-    expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
-    1.upto(12) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 9}>#{Date::MONTHNAMES[i]}</option>\n) }
-    expected << "</select>\n"
-    expected << %{<select id="post_updated_at_3i" name="post[updated_at(3i)]">\n}
-    1.upto(31) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 19}>#{i}</option>\n) }
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %{<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n}
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 15}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << " : "
-    expected << %{<select id="post_updated_at_5i" name="post[updated_at(5i)]">\n}
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 16}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, datetime_select("post", "updated_at", :default => Time.local(2006, 9, 19, 15, 16, 35))
-  end
-
-  def test_include_blank_overrides_default_option
-    @post = Post.new
-    @post.updated_at = nil
-
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
-    expected << %(<option value=""></option>\n)
-    (Time.now.year - 5).upto(Time.now.year + 5) { |i| expected << %(<option value="#{i}">#{i}</option>\n) }
-    expected << "</select>\n"
-    expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
-    expected << %(<option value=""></option>\n)
-    1.upto(12) { |i| expected << %(<option value="#{i}">#{Date::MONTHNAMES[i]}</option>\n) }
-    expected << "</select>\n"
-    expected << %{<select id="post_updated_at_3i" name="post[updated_at(3i)]">\n}
-    expected << %(<option value=""></option>\n)
-    1.upto(31) { |i| expected << %(<option value="#{i}">#{i}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, date_select("post", "updated_at", :default => Time.local(2006, 9, 19, 15, 16, 35), :include_blank => true)
-  end
-
-  def test_datetime_select_with_default_value_as_hash
-    @post = Post.new
-    @post.updated_at = nil
-
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]">\n}
-    (Time.now.year - 5).upto(Time.now.year + 5) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == Time.now.year}>#{i}</option>\n) }
-    expected << "</select>\n"
-    expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]">\n}
-    1.upto(12) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == 10}>#{Date::MONTHNAMES[i]}</option>\n) }
-    expected << "</select>\n"
-    expected << %{<select id="post_updated_at_3i" name="post[updated_at(3i)]">\n}
-    1.upto(31) { |i| expected << %(<option value="#{i}"#{' selected="selected"' if i == Time.now.day}>#{i}</option>\n) }
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %{<select id="post_updated_at_4i" name="post[updated_at(4i)]">\n}
-    0.upto(23) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 9}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-    expected << " : "
-    expected << %{<select id="post_updated_at_5i" name="post[updated_at(5i)]">\n}
-    0.upto(59) { |i| expected << %(<option value="#{sprintf("%02d", i)}"#{' selected="selected"' if i == 42}>#{sprintf("%02d", i)}</option>\n) }
-    expected << "</select>\n"
-
-    assert_dom_equal expected, datetime_select("post", "updated_at", :default => { :month => 10, :minute => 42, :hour => 9 })
-  end
-
-  def test_datetime_select_with_html_options
-    @post = Post.new
-    @post.updated_at = Time.local(2004, 6, 15, 16, 35)
-
-    expected = %{<select id="post_updated_at_1i" name="post[updated_at(1i)]" class="selector">\n}
-    expected << %{<option value="1999">1999</option>\n<option value="2000">2000</option>\n<option value="2001">2001</option>\n<option value="2002">2002</option>\n<option value="2003">2003</option>\n<option value="2004" selected="selected">2004</option>\n<option value="2005">2005</option>\n<option value="2006">2006</option>\n<option value="2007">2007</option>\n<option value="2008">2008</option>\n<option value="2009">2009</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_updated_at_2i" name="post[updated_at(2i)]" class="selector">\n}
-    expected << %{<option value="1">January</option>\n<option value="2">February</option>\n<option value="3">March</option>\n<option value="4">April</option>\n<option value="5">May</option>\n<option value="6" selected="selected">June</option>\n<option value="7">July</option>\n<option value="8">August</option>\n<option value="9">September</option>\n<option value="10">October</option>\n<option value="11">November</option>\n<option value="12">December</option>\n}
-    expected << "</select>\n"
-
-    expected << %{<select id="post_updated_at_3i" name="post[updated_at(3i)]" class="selector">\n}
-    expected << %{<option value="1">1</option>\n<option value="2">2</option>\n<option value="3">3</option>\n<option value="4">4</option>\n<option value="5">5</option>\n<option value="6">6</option>\n<option value="7">7</option>\n<option value="8">8</option>\n<option value="9">9</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15" selected="selected">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n}
-    expected << "</select>\n"
-
-    expected << " &mdash; "
-
-    expected << %{<select id="post_updated_at_4i" name="post[updated_at(4i)]" class="selector">\n}
-    expected << %{<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16" selected="selected">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n}
-    expected << "</select>\n"
-    expected << " : "
-    expected << %{<select id="post_updated_at_5i" name="post[updated_at(5i)]" class="selector">\n}
-    expected << %{<option value="00">00</option>\n<option value="01">01</option>\n<option value="02">02</option>\n<option value="03">03</option>\n<option value="04">04</option>\n<option value="05">05</option>\n<option value="06">06</option>\n<option value="07">07</option>\n<option value="08">08</option>\n<option value="09">09</option>\n<option value="10">10</option>\n<option value="11">11</option>\n<option value="12">12</option>\n<option value="13">13</option>\n<option value="14">14</option>\n<option value="15">15</option>\n<option value="16">16</option>\n<option value="17">17</option>\n<option value="18">18</option>\n<option value="19">19</option>\n<option value="20">20</option>\n<option value="21">21</option>\n<option value="22">22</option>\n<option value="23">23</option>\n<option value="24">24</option>\n<option value="25">25</option>\n<option value="26">26</option>\n<option value="27">27</option>\n<option value="28">28</option>\n<option value="29">29</option>\n<option value="30">30</option>\n<option value="31">31</option>\n<option value="32">32</option>\n<option value="33">33</option>\n<option value="34">34</option>\n<option value="35" selected="selected">35</option>\n<option value="36">36</option>\n<option value="37">37</option>\n<option value="38">38</option>\n<option value="39">39</option>\n<option value="40">40</option>\n<option value="41">41</option>\n<option value="42">42</option>\n<option value="43">43</option>\n<option value="44">44</option>\n<option value="45">45</option>\n<option value="46">46</option>\n<option value="47">47</option>\n<option value="48">48</option>\n<option value="49">49</option>\n<option value="50">50</option>\n<option value="51">51</option>\n<option value="52">52</option>\n<option value="53">53</option>\n<option value="54">54</option>\n<option value="55">55</option>\n<option value="56">56</option>\n<option value="57">57</option>\n<option value="58">58</option>\n<option value="59">59</option>\n}
-    expected << "</select>\n"
-
-    assert_dom_equal expected, datetime_select("post", "updated_at", {}, :class => 'selector')
-  end
-
-  def test_date_select_should_not_change_passed_options_hash
-    @post = Post.new
-    @post.updated_at = Time.local(2008, 7, 16, 23, 30)
-
-    options = {
-      :order => [ :year, :month, :day ],
-      :default => { :year => 2008, :month => 7, :day => 16, :hour => 23, :minute => 30, :second => 1 },
-      :discard_type => false,
-      :include_blank => false,
-      :ignore_date => false,
-      :include_seconds => true
-    }
-    date_select(@post, :updated_at, options)
-
-    # note: the literal hash is intentional to show that the actual options hash isn't modified
-    #       don't change this!
-    assert_equal({
-      :order => [ :year, :month, :day ],
-      :default => { :year => 2008, :month => 7, :day => 16, :hour => 23, :minute => 30, :second => 1 },
-      :discard_type => false,
-      :include_blank => false,
-      :ignore_date => false,
-      :include_seconds => true
-    }, options)
-  end
-
-  def test_datetime_select_should_not_change_passed_options_hash
-    @post = Post.new
-    @post.updated_at = Time.local(2008, 7, 16, 23, 30)
-
-    options = {
-      :order => [ :year, :month, :day ],
-      :default => { :year => 2008, :month => 7, :day => 16, :hour => 23, :minute => 30, :second => 1 },
-      :discard_type => false,
-      :include_blank => false,
-      :ignore_date => false,
-      :include_seconds => true
-    }
-    datetime_select(@post, :updated_at, options)
-
-    # note: the literal hash is intentional to show that the actual options hash isn't modified
-    #       don't change this!
-    assert_equal({
-      :order => [ :year, :month, :day ],
-      :default => { :year => 2008, :month => 7, :day => 16, :hour => 23, :minute => 30, :second => 1 },
-      :discard_type => false,
-      :include_blank => false,
-      :ignore_date => false,
-      :include_seconds => true
-    }, options)
-  end
-
-  def test_time_select_should_not_change_passed_options_hash
-    @post = Post.new
-    @post.updated_at = Time.local(2008, 7, 16, 23, 30)
-
-    options = {
-      :order => [ :year, :month, :day ],
-      :default => { :year => 2008, :month => 7, :day => 16, :hour => 23, :minute => 30, :second => 1 },
-      :discard_type => false,
-      :include_blank => false,
-      :ignore_date => false,
-      :include_seconds => true
-    }
-    time_select(@post, :updated_at, options)
-
-    # note: the literal hash is intentional to show that the actual options hash isn't modified
-    #       don't change this!
-    assert_equal({
-      :order => [ :year, :month, :day ],
-      :default => { :year => 2008, :month => 7, :day => 16, :hour => 23, :minute => 30, :second => 1 },
-      :discard_type => false,
-      :include_blank => false,
-      :ignore_date => false,
-      :include_seconds => true
-    }, options)
-  end
-
-  def test_select_date_should_not_change_passed_options_hash
-    options = {
-      :order => [ :year, :month, :day ],
-      :default => { :year => 2008, :month => 7, :day => 16, :hour => 23, :minute => 30, :second => 1 },
-      :discard_type => false,
-      :include_blank => false,
-      :ignore_date => false,
-      :include_seconds => true
-    }
-    select_date(Date.today, options)
-
-    # note: the literal hash is intentional to show that the actual options hash isn't modified
-    #       don't change this!
-    assert_equal({
-      :order => [ :year, :month, :day ],
-      :default => { :year => 2008, :month => 7, :day => 16, :hour => 23, :minute => 30, :second => 1 },
-      :discard_type => false,
-      :include_blank => false,
-      :ignore_date => false,
-      :include_seconds => true
-    }, options)
-  end
-
-  def test_select_datetime_should_not_change_passed_options_hash
-    options = {
-      :order => [ :year, :month, :day ],
-      :default => { :year => 2008, :month => 7, :day => 16, :hour => 23, :minute => 30, :second => 1 },
-      :discard_type => false,
-      :include_blank => false,
-      :ignore_date => false,
-      :include_seconds => true
-    }
-    select_datetime(Time.now, options)
-
-    # note: the literal hash is intentional to show that the actual options hash isn't modified
-    #       don't change this!
-    assert_equal({
-      :order => [ :year, :month, :day ],
-      :default => { :year => 2008, :month => 7, :day => 16, :hour => 23, :minute => 30, :second => 1 },
-      :discard_type => false,
-      :include_blank => false,
-      :ignore_date => false,
-      :include_seconds => true
-    }, options)
-  end
-
-  def test_select_time_should_not_change_passed_options_hash
-    options = {
-      :order => [ :year, :month, :day ],
-      :default => { :year => 2008, :month => 7, :day => 16, :hour => 23, :minute => 30, :second => 1 },
-      :discard_type => false,
-      :include_blank => false,
-      :ignore_date => false,
-      :include_seconds => true
-    }
-    select_time(Time.now, options)
-
-    # note: the literal hash is intentional to show that the actual options hash isn't modified
-    #       don't change this!
-    assert_equal({
-      :order => [ :year, :month, :day ],
-      :default => { :year => 2008, :month => 7, :day => 16, :hour => 23, :minute => 30, :second => 1 },
-      :discard_type => false,
-      :include_blank => false,
-      :ignore_date => false,
-      :include_seconds => true
-    }, options)
-  end
-
-  def test_select_html_safety
-    assert select_day(16).html_safe?
-    assert select_month(8).html_safe?
-    assert select_year(Time.mktime(2003, 8, 16, 8, 4, 18)).html_safe?
-    assert select_minute(Time.mktime(2003, 8, 16, 8, 4, 18)).html_safe?
-    assert select_second(Time.mktime(2003, 8, 16, 8, 4, 18)).html_safe?
-
-    assert select_minute(8, :use_hidden => true).html_safe?
-    assert select_month(8, :prompt => 'Choose month').html_safe?
-
-    assert select_time(Time.mktime(2003, 8, 16, 8, 4, 18), {}, :class => 'selector').html_safe?
-    assert select_date(Time.mktime(2003, 8, 16), :date_separator => " / ", :start_year => 2003, :end_year => 2005, :prefix => "date[first]").html_safe?
-  end
-
-  def test_object_select_html_safety
-    @post = Post.new
-    @post.written_on = Date.new(2004, 6, 15)
-
-    assert date_select("post", "written_on", :default => Time.local(2006, 9, 19, 15, 16, 35), :include_blank => true).html_safe?
-    assert time_select("post", "written_on", :ignore_date => true).html_safe?
-  end
-
-  def test_time_tag_with_date
-    date = Date.new(2013, 2, 20)
-    expected = '<time datetime="2013-02-20">February 20, 2013</time>'
-    assert_equal expected, time_tag(date)
-  end
-
-  def test_time_tag_with_time
-    time = Time.new(2013, 2, 20, 0, 0, 0, '+00:00')
-    expected = '<time datetime="2013-02-20T00:00:00+00:00">February 20, 2013 00:00</time>'
-    assert_equal expected, time_tag(time)
-  end
-
-  def test_time_tag_pubdate_option
-    assert_match(/<time.*pubdate="pubdate">.*<\/time>/, time_tag(Time.now, :pubdate => true))
-  end
-
-  def test_time_tag_with_given_text
-    assert_match(/<time.*>Right now<\/time>/, time_tag(Time.now, 'Right now'))
-  end
-
-  def test_time_tag_with_given_block
-    assert_match(/<time.*><span>Right now<\/span><\/time>/, time_tag(Time.now){ '<span>Right now</span>'.html_safe })
-  end
-
-  def test_time_tag_with_different_format
-    time = Time.new(2013, 2, 20, 0, 0, 0, '+00:00')
-    expected = '<time datetime="2013-02-20T00:00:00+00:00">20 Feb 00:00</time>'
-    assert_equal expected, time_tag(time, :format => :short)
-  end
-
-  protected
-    def with_env_tz(new_tz = 'US/Eastern')
-      old_tz, ENV['TZ'] = ENV['TZ'], new_tz
-      yield
-    ensure
-      old_tz ? ENV['TZ'] = old_tz : ENV.delete('TZ')
-    end
-end
diff --git a/actionpack/test/template/debug_helper_test.rb b/actionpack/test/template/debug_helper_test.rb
deleted file mode 100644
index 42d06bd9ff..0000000000
--- a/actionpack/test/template/debug_helper_test.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-require 'active_record_unit'
-
-class DebugHelperTest < ActionView::TestCase
-  def test_debug
-    company = Company.new(name: "firebase")
-    assert_match "&nbsp; name: firebase", debug(company)
-  end
-end
diff --git a/actionpack/test/template/dependency_tracker_test.rb b/actionpack/test/template/dependency_tracker_test.rb
deleted file mode 100644
index 9c68afbdbd..0000000000
--- a/actionpack/test/template/dependency_tracker_test.rb
+++ /dev/null
@@ -1,46 +0,0 @@
-require 'abstract_unit'
-require 'action_view/dependency_tracker'
-
-class DependencyTrackerTest < ActionView::TestCase
-  Neckbeard = lambda {|template| template.source }
-  Bowtie = lambda {|template| template.source }
-
-  class NeckbeardTracker
-    def self.call(name, template)
-      ["foo/#{name}"]
-    end
-  end
-
-  class FakeTemplate
-    attr_reader :source, :handler
-
-    def initialize(source, handler = Neckbeard)
-      @source, @handler = source, handler
-    end
-  end
-
-  def tracker
-    ActionView::DependencyTracker
-  end
-
-  def setup
-    ActionView::Template.register_template_handler :neckbeard, Neckbeard
-    tracker.register_tracker(:neckbeard, NeckbeardTracker)
-  end
-
-  def teardown
-    tracker.remove_tracker(:neckbeard)
-  end
-
-  def test_finds_tracker_by_template_handler
-    template = FakeTemplate.new("boo/hoo")
-    dependencies = tracker.find_dependencies("boo/hoo", template)
-    assert_equal ["foo/boo/hoo"], dependencies
-  end
-
-  def test_returns_empty_array_if_no_tracker_is_found
-    template = FakeTemplate.new("boo/hoo", Bowtie)
-    dependencies = tracker.find_dependencies("boo/hoo", template)
-    assert_equal [], dependencies
-  end
-end
diff --git a/actionpack/test/template/digestor_test.rb b/actionpack/test/template/digestor_test.rb
deleted file mode 100644
index 06735c30d3..0000000000
--- a/actionpack/test/template/digestor_test.rb
+++ /dev/null
@@ -1,197 +0,0 @@
-require 'abstract_unit'
-require 'fileutils'
-
-class FixtureTemplate
-  attr_reader :source, :handler
-
-  def initialize(template_path)
-    @source = File.read(template_path)
-    @handler = ActionView::Template.handler_for_extension(:erb)
-  rescue Errno::ENOENT
-    raise ActionView::MissingTemplate.new([], "", [], true, [])
-  end
-end
-
-class FixtureFinder
-  FIXTURES_DIR = "#{File.dirname(__FILE__)}/../fixtures/digestor"
-
-  def find(logical_name, keys, partial, options)
-    FixtureTemplate.new("digestor/#{partial ? logical_name.gsub(%r|/([^/]+)$|, '/_\1') : logical_name}.#{options[:formats].first}.erb")
-  end
-end
-
-class TemplateDigestorTest < ActionView::TestCase
-  def setup
-    @cwd     = Dir.pwd
-    @tmp_dir = Dir.mktmpdir
-
-    FileUtils.cp_r FixtureFinder::FIXTURES_DIR, @tmp_dir
-    Dir.chdir @tmp_dir
-  end
-
-  def teardown
-    Dir.chdir @cwd
-    FileUtils.rm_r @tmp_dir
-    ActionView::Digestor.cache.clear
-  end
-
-  def test_top_level_change_reflected
-    assert_digest_difference("messages/show") do
-      change_template("messages/show")
-    end
-  end
-
-  def test_explicit_dependency
-    assert_digest_difference("messages/show") do
-      change_template("messages/_message")
-    end
-  end
-
-  def test_explicit_dependency_in_multiline_erb_tag
-    assert_digest_difference("messages/show") do
-      change_template("messages/_form")
-    end
-  end
-
-  def test_second_level_dependency
-    assert_digest_difference("messages/show") do
-      change_template("comments/_comments")
-    end
-  end
-
-  def test_second_level_dependency_within_same_directory
-    assert_digest_difference("messages/show") do
-      change_template("messages/_header")
-    end
-  end
-
-  def test_third_level_dependency
-    assert_digest_difference("messages/show") do
-      change_template("comments/_comment")
-    end
-  end
-
-  def test_directory_depth_dependency
-    assert_digest_difference("level/below/index") do
-      change_template("level/below/_header")
-    end
-  end
-
-  def test_logging_of_missing_template
-    assert_logged "Couldn't find template for digesting: messages/something_missing.html" do
-      digest("messages/show")
-    end
-  end
-
-  def test_logging_of_missing_template_ending_with_number
-    assert_logged "Couldn't find template for digesting: messages/something_missing_1.html" do
-      digest("messages/show")
-    end
-  end
-
-  def test_nested_template_directory
-    assert_digest_difference("messages/show") do
-      change_template("messages/actions/_move")
-    end
-  end
-
-  def test_dont_generate_a_digest_for_missing_templates
-    assert_equal '', digest("nothing/there")
-  end
-
-  def test_collection_dependency
-    assert_digest_difference("messages/index") do
-      change_template("messages/_message")
-    end
-
-    assert_digest_difference("messages/index") do
-      change_template("events/_event")
-    end
-  end
-
-  def test_collection_derived_from_record_dependency
-    assert_digest_difference("messages/show") do
-      change_template("events/_event")
-    end
-  end
-
-  def test_extra_whitespace_in_render_partial
-    assert_digest_difference("messages/edit") do
-      change_template("messages/_form")
-    end
-  end
-
-  def test_extra_whitespace_in_render_named_partial
-    assert_digest_difference("messages/edit") do
-      change_template("messages/_header")
-    end
-  end
-
-  def test_extra_whitespace_in_render_record
-    assert_digest_difference("messages/edit") do
-      change_template("messages/_message")
-    end
-  end
-
-  def test_extra_whitespace_in_render_with_parenthesis
-    assert_digest_difference("messages/edit") do
-      change_template("events/_event")
-    end
-  end
-
-  def test_old_style_hash_in_render_invocation
-    assert_digest_difference("messages/edit") do
-      change_template("comments/_comment")
-    end
-  end
-
-  def test_dependencies_via_options_results_in_different_digest
-    digest_plain        = digest("comments/_comment")
-    digest_fridge       = digest("comments/_comment", dependencies: ["fridge"])
-    digest_phone        = digest("comments/_comment", dependencies: ["phone"])
-    digest_fridge_phone = digest("comments/_comment", dependencies: ["fridge", "phone"])
-
-    assert_not_equal digest_plain, digest_fridge
-    assert_not_equal digest_plain, digest_phone
-    assert_not_equal digest_plain, digest_fridge_phone
-    assert_not_equal digest_fridge, digest_phone
-    assert_not_equal digest_fridge, digest_fridge_phone
-    assert_not_equal digest_phone, digest_fridge_phone
-  end
-
-  private
-    def assert_logged(message)
-      old_logger = ActionView::Base.logger
-      log = StringIO.new
-      ActionView::Base.logger = Logger.new(log)
-
-      begin
-        yield
-
-        log.rewind
-        assert_match message, log.read
-      ensure
-        ActionView::Base.logger = old_logger
-      end
-    end
-
-    def assert_digest_difference(template_name)
-      previous_digest = digest(template_name)
-      ActionView::Digestor.cache.clear
-
-      yield
-
-      assert previous_digest != digest(template_name), "digest didn't change"
-      ActionView::Digestor.cache.clear
-    end
-
-    def digest(template_name, options={})
-      ActionView::Digestor.digest(template_name, :html, FixtureFinder.new, options)
-    end
-
-    def change_template(template_name)
-      File.open("digestor/#{template_name}.html.erb", "w") do |f|
-        f.write "\nTHIS WAS CHANGED!"
-      end
-    end
-end
diff --git a/actionpack/test/template/erb/form_for_test.rb b/actionpack/test/template/erb/form_for_test.rb
deleted file mode 100644
index e722b40a9a..0000000000
--- a/actionpack/test/template/erb/form_for_test.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-require "abstract_unit"
-require "template/erb/helper"
-
-module ERBTest
-  class TagHelperTest < BlockTestCase
-    test "form_for works" do
-      output = render_content "form_for(:staticpage, :url => {:controller => 'blah', :action => 'update'})", ""
-      assert_match %r{<form.*action="/blah/update".*method="post">.*</form>}, output
-    end
-  end
-end
diff --git a/actionpack/test/template/erb/helper.rb b/actionpack/test/template/erb/helper.rb
deleted file mode 100644
index a1973068d5..0000000000
--- a/actionpack/test/template/erb/helper.rb
+++ /dev/null
@@ -1,24 +0,0 @@
-module ERBTest
-  class ViewContext
-    include ActionView::Helpers::UrlHelper
-    include SharedTestRoutes.url_helpers
-    include ActionView::Helpers::TagHelper
-    include ActionView::Helpers::JavaScriptHelper
-    include ActionView::Helpers::FormHelper
-
-    attr_accessor :output_buffer, :controller
-
-    def protect_against_forgery?() false end
-  end
-
-  class BlockTestCase < ActiveSupport::TestCase
-    def render_content(start, inside)
-      template = block_helper(start, inside)
-      ActionView::Template::Handlers::Erubis.new(template).evaluate(ViewContext.new)
-    end
-
-    def block_helper(str, rest)
-      "<%= #{str} do %>#{rest}<% end %>"
-    end
-  end
-end
diff --git a/actionpack/test/template/erb/tag_helper_test.rb b/actionpack/test/template/erb/tag_helper_test.rb
deleted file mode 100644
index 84e328d8be..0000000000
--- a/actionpack/test/template/erb/tag_helper_test.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-require "abstract_unit"
-require "template/erb/helper"
-
-module ERBTest
-  class TagHelperTest < BlockTestCase
-    test "percent equals works for content_tag and does not require parenthesis on method call" do
-      assert_equal "<div>Hello world</div>", render_content("content_tag :div", "Hello world")
-    end
-
-    test "percent equals works for javascript_tag" do
-      expected_output = "<script>\n//<![CDATA[\nalert('Hello')\n//]]>\n</script>"
-      assert_equal expected_output, render_content("javascript_tag", "alert('Hello')")
-    end
-
-    test "percent equals works for javascript_tag with options" do
-      expected_output = "<script id=\"the_js_tag\">\n//<![CDATA[\nalert('Hello')\n//]]>\n</script>"
-      assert_equal expected_output, render_content("javascript_tag(:id => 'the_js_tag')", "alert('Hello')")
-    end
-
-    test "percent equals works with form tags" do
-      expected_output = %r{<form.*action="foo".*method="post">.*hello*</form>}
-      assert_match expected_output, render_content("form_tag('foo')", "<%= 'hello' %>")
-    end
-
-    test "percent equals works with fieldset tags" do
-      expected_output = "<fieldset><legend>foo</legend>hello</fieldset>"
-      assert_equal expected_output, render_content("field_set_tag('foo')", "<%= 'hello' %>")
-    end
-  end
-end
diff --git a/actionpack/test/template/erb_util_test.rb b/actionpack/test/template/erb_util_test.rb
deleted file mode 100644
index 3e5b029cea..0000000000
--- a/actionpack/test/template/erb_util_test.rb
+++ /dev/null
@@ -1,60 +0,0 @@
-require 'abstract_unit'
-
-class ErbUtilTest < ActiveSupport::TestCase
-  include ERB::Util
-
-  ERB::Util::HTML_ESCAPE.each do |given, expected|
-    define_method "test_html_escape_#{expected.gsub(/\W/, '')}" do
-      assert_equal expected, html_escape(given)
-    end
-  end
-
-  ERB::Util::JSON_ESCAPE.each do |given, expected|
-    define_method "test_json_escape_#{expected.gsub(/\W/, '')}" do
-      assert_equal ERB::Util::JSON_ESCAPE[given], json_escape(given)
-    end
-  end
-
-  def test_json_escape_returns_unsafe_strings_when_passed_unsafe_strings
-    value = json_escape("asdf")
-    assert !value.html_safe?
-  end
-
-  def test_json_escape_returns_safe_strings_when_passed_safe_strings
-    value = json_escape("asdf".html_safe)
-    assert value.html_safe?
-  end
-
-  def test_html_escape_is_html_safe
-    escaped = h("<p>")
-    assert_equal "&lt;p&gt;", escaped
-    assert escaped.html_safe?
-  end
-
-  def test_html_escape_passes_html_escpe_unmodified
-    escaped = h("<p>".html_safe)
-    assert_equal "<p>", escaped
-    assert escaped.html_safe?
-  end
-
-  def test_rest_in_ascii
-    (0..127).to_a.map {|int| int.chr }.each do |chr|
-      next if %('"&<>).include?(chr)
-      assert_equal chr, html_escape(chr)
-    end
-  end
-
-  def test_html_escape_once
-    assert_equal '1 &lt;&gt;&amp;&quot;&#39; 2 &amp; 3', html_escape_once('1 <>&"\' 2 &amp; 3')
-  end
-
-  def test_html_escape_once_returns_unsafe_strings_when_passed_unsafe_strings
-    value = html_escape_once('1 < 2 &amp; 3')
-    assert !value.html_safe?
-  end
-
-  def test_html_escape_once_returns_safe_strings_when_passed_safe_strings
-    value = html_escape_once('1 < 2 &amp; 3'.html_safe)
-    assert value.html_safe?
-  end
-end
diff --git a/actionpack/test/template/form_collections_helper_test.rb b/actionpack/test/template/form_collections_helper_test.rb
deleted file mode 100644
index 2131f81396..0000000000
--- a/actionpack/test/template/form_collections_helper_test.rb
+++ /dev/null
@@ -1,342 +0,0 @@
-require 'abstract_unit'
-
-class Category < Struct.new(:id, :name)
-end
-
-class FormCollectionsHelperTest < ActionView::TestCase
-  def assert_no_select(selector, value = nil)
-    assert_select(selector, :text => value, :count => 0)
-  end
-
-  def with_collection_radio_buttons(*args, &block)
-    @output_buffer = collection_radio_buttons(*args, &block)
-  end
-
-  def with_collection_check_boxes(*args, &block)
-    @output_buffer = collection_check_boxes(*args, &block)
-  end
-
-  # COLLECTION RADIO BUTTONS
-  test 'collection radio accepts a collection and generate inputs from value method' do
-    with_collection_radio_buttons :user, :active, [true, false], :to_s, :to_s
-
-    assert_select 'input[type=radio][value=true]#user_active_true'
-    assert_select 'input[type=radio][value=false]#user_active_false'
-  end
-
-  test 'collection radio accepts a collection and generate inputs from label method' do
-    with_collection_radio_buttons :user, :active, [true, false], :to_s, :to_s
-
-    assert_select 'label[for=user_active_true]', 'true'
-    assert_select 'label[for=user_active_false]', 'false'
-  end
-
-  test 'collection radio handles camelized collection values for labels correctly' do
-    with_collection_radio_buttons :user, :active, ['Yes', 'No'], :to_s, :to_s
-
-    assert_select 'label[for=user_active_yes]', 'Yes'
-    assert_select 'label[for=user_active_no]', 'No'
-  end
-
-  test 'colection radio should sanitize collection values for labels correctly' do
-    with_collection_radio_buttons :user, :name, ['$0.99', '$1.99'], :to_s, :to_s
-    assert_select 'label[for=user_name_099]', '$0.99'
-    assert_select 'label[for=user_name_199]', '$1.99'
-  end
-
-  test 'collection radio accepts checked item' do
-    with_collection_radio_buttons :user, :active, [[1, true], [0, false]], :last, :first, :checked => true
-
-    assert_select 'input[type=radio][value=true][checked=checked]'
-    assert_no_select 'input[type=radio][value=false][checked=checked]'
-  end
-
-  test 'collection radio accepts multiple disabled items' do
-    collection = [[1, true], [0, false], [2, 'other']]
-    with_collection_radio_buttons :user, :active, collection, :last, :first, :disabled => [true, false]
-
-    assert_select 'input[type=radio][value=true][disabled=disabled]'
-    assert_select 'input[type=radio][value=false][disabled=disabled]'
-    assert_no_select 'input[type=radio][value=other][disabled=disabled]'
-  end
-
-  test 'collection radio accepts single disable item' do
-    collection = [[1, true], [0, false]]
-    with_collection_radio_buttons :user, :active, collection, :last, :first, :disabled => true
-
-    assert_select 'input[type=radio][value=true][disabled=disabled]'
-    assert_no_select 'input[type=radio][value=false][disabled=disabled]'
-  end
-
-  test 'collection radio accepts html options as input' do
-    collection = [[1, true], [0, false]]
-    with_collection_radio_buttons :user, :active, collection, :last, :first, {}, :class => 'special-radio'
-
-    assert_select 'input[type=radio][value=true].special-radio#user_active_true'
-    assert_select 'input[type=radio][value=false].special-radio#user_active_false'
-  end
-
-  test 'collection radio does not wrap input inside the label' do
-    with_collection_radio_buttons :user, :active, [true, false], :to_s, :to_s
-
-    assert_select 'input[type=radio] + label'
-    assert_no_select 'label input'
-  end
-
-  test 'collection radio accepts a block to render the label as radio button wrapper' do
-    with_collection_radio_buttons :user, :active, [true, false], :to_s, :to_s do |b|
-      b.label { b.radio_button }
-    end
-
-    assert_select 'label[for=user_active_true] > input#user_active_true[type=radio]'
-    assert_select 'label[for=user_active_false] > input#user_active_false[type=radio]'
-  end
-
-  test 'collection radio accepts a block to change the order of label and radio button' do
-    with_collection_radio_buttons :user, :active, [true, false], :to_s, :to_s do |b|
-      b.label + b.radio_button
-    end
-
-    assert_select 'label[for=user_active_true] + input#user_active_true[type=radio]'
-    assert_select 'label[for=user_active_false] + input#user_active_false[type=radio]'
-  end
-
-  test 'collection radio with block helpers accept extra html options' do
-    with_collection_radio_buttons :user, :active, [true, false], :to_s, :to_s do |b|
-      b.label(:class => "radio_button") + b.radio_button(:class => "radio_button")
-    end
-
-    assert_select 'label.radio_button[for=user_active_true] + input#user_active_true.radio_button[type=radio]'
-    assert_select 'label.radio_button[for=user_active_false] + input#user_active_false.radio_button[type=radio]'
-  end
-
-  test 'collection radio with block helpers allows access to current text and value' do
-    with_collection_radio_buttons :user, :active, [true, false], :to_s, :to_s do |b|
-      b.label(:"data-value" => b.value) { b.radio_button + b.text }
-    end
-
-    assert_select 'label[for=user_active_true][data-value=true]', 'true' do
-      assert_select 'input#user_active_true[type=radio]'
-    end
-    assert_select 'label[for=user_active_false][data-value=false]', 'false' do
-      assert_select 'input#user_active_false[type=radio]'
-    end
-  end
-
-  test 'collection radio with block helpers allows access to the current object item in the collection to access extra properties' do
-    with_collection_radio_buttons :user, :active, [true, false], :to_s, :to_s do |b|
-      b.label(:class => b.object) { b.radio_button + b.text }
-    end
-
-    assert_select 'label.true[for=user_active_true]', 'true' do
-      assert_select 'input#user_active_true[type=radio]'
-    end
-    assert_select 'label.false[for=user_active_false]', 'false' do
-      assert_select 'input#user_active_false[type=radio]'
-    end
-  end
-
-  test 'collection radio buttons with fields for' do
-    collection = [Category.new(1, 'Category 1'), Category.new(2, 'Category 2')]
-    @output_buffer = fields_for(:post) do |p|
-      p.collection_radio_buttons :category_id, collection, :id, :name
-    end
-
-    assert_select 'input#post_category_id_1[type=radio][value=1]'
-    assert_select 'input#post_category_id_2[type=radio][value=2]'
-
-    assert_select 'label[for=post_category_id_1]', 'Category 1'
-    assert_select 'label[for=post_category_id_2]', 'Category 2'
-  end
-
-  test 'collection radio accepts checked item which has a value of false' do
-    with_collection_radio_buttons :user, :active, [[1, true], [0, false]], :last, :first, :checked => false
-    assert_no_select 'input[type=radio][value=true][checked=checked]'
-    assert_select 'input[type=radio][value=false][checked=checked]'
-  end
-
-  # COLLECTION CHECK BOXES
-  test 'collection check boxes accepts a collection and generate a serie of checkboxes for value method' do
-    collection = [Category.new(1, 'Category 1'), Category.new(2, 'Category 2')]
-    with_collection_check_boxes :user, :category_ids, collection, :id, :name
-
-    assert_select 'input#user_category_ids_1[type=checkbox][value=1]'
-    assert_select 'input#user_category_ids_2[type=checkbox][value=2]'
-  end
-
-  test 'collection check boxes generates only one hidden field for the entire collection, to ensure something will be sent back to the server when posting an empty collection' do
-    collection = [Category.new(1, 'Category 1'), Category.new(2, 'Category 2')]
-    with_collection_check_boxes :user, :category_ids, collection, :id, :name
-
-    assert_select "input[type=hidden][name='user[category_ids][]'][value=]", :count => 1
-  end
-
-  test 'collection check boxes accepts a collection and generate a serie of checkboxes with labels for label method' do
-    collection = [Category.new(1, 'Category 1'), Category.new(2, 'Category 2')]
-    with_collection_check_boxes :user, :category_ids, collection, :id, :name
-
-    assert_select 'label[for=user_category_ids_1]', 'Category 1'
-    assert_select 'label[for=user_category_ids_2]', 'Category 2'
-  end
-
-  test 'collection check boxes handles camelized collection values for labels correctly' do
-    with_collection_check_boxes :user, :active, ['Yes', 'No'], :to_s, :to_s
-
-    assert_select 'label[for=user_active_yes]', 'Yes'
-    assert_select 'label[for=user_active_no]', 'No'
-  end
-
-  test 'colection check box should sanitize collection values for labels correctly' do
-    with_collection_check_boxes :user, :name, ['$0.99', '$1.99'], :to_s, :to_s
-    assert_select 'label[for=user_name_099]', '$0.99'
-    assert_select 'label[for=user_name_199]', '$1.99'
-  end
-
-  test 'collection check boxes accepts selected values as :checked option' do
-    collection = (1..3).map{|i| [i, "Category #{i}"] }
-    with_collection_check_boxes :user, :category_ids, collection, :first, :last, :checked => [1, 3]
-
-    assert_select 'input[type=checkbox][value=1][checked=checked]'
-    assert_select 'input[type=checkbox][value=3][checked=checked]'
-    assert_no_select 'input[type=checkbox][value=2][checked=checked]'
-  end
-
-  test 'collection check boxes accepts selected string values as :checked option' do
-    collection = (1..3).map{|i| [i, "Category #{i}"] }
-    with_collection_check_boxes :user, :category_ids, collection, :first, :last, :checked => ['1', '3']
-
-    assert_select 'input[type=checkbox][value=1][checked=checked]'
-    assert_select 'input[type=checkbox][value=3][checked=checked]'
-    assert_no_select 'input[type=checkbox][value=2][checked=checked]'
-  end
-
-  test 'collection check boxes accepts a single checked value' do
-    collection = (1..3).map{|i| [i, "Category #{i}"] }
-    with_collection_check_boxes :user, :category_ids, collection, :first, :last, :checked => 3
-
-    assert_select 'input[type=checkbox][value=3][checked=checked]'
-    assert_no_select 'input[type=checkbox][value=1][checked=checked]'
-    assert_no_select 'input[type=checkbox][value=2][checked=checked]'
-  end
-
-  test 'collection check boxes accepts selected values as :checked option and override the model values' do
-    user = Struct.new(:category_ids).new(2)
-    collection = (1..3).map{|i| [i, "Category #{i}"] }
-
-    @output_buffer = fields_for(:user, user) do |p|
-      p.collection_check_boxes :category_ids, collection, :first, :last, :checked => [1, 3]
-    end
-
-    assert_select 'input[type=checkbox][value=1][checked=checked]'
-    assert_select 'input[type=checkbox][value=3][checked=checked]'
-    assert_no_select 'input[type=checkbox][value=2][checked=checked]'
-  end
-
-  test 'collection check boxes accepts multiple disabled items' do
-    collection = (1..3).map{|i| [i, "Category #{i}"] }
-    with_collection_check_boxes :user, :category_ids, collection, :first, :last, :disabled => [1, 3]
-
-    assert_select 'input[type=checkbox][value=1][disabled=disabled]'
-    assert_select 'input[type=checkbox][value=3][disabled=disabled]'
-    assert_no_select 'input[type=checkbox][value=2][disabled=disabled]'
-  end
-
-  test 'collection check boxes accepts single disable item' do
-    collection = (1..3).map{|i| [i, "Category #{i}"] }
-    with_collection_check_boxes :user, :category_ids, collection, :first, :last, :disabled => 1
-
-    assert_select 'input[type=checkbox][value=1][disabled=disabled]'
-    assert_no_select 'input[type=checkbox][value=3][disabled=disabled]'
-    assert_no_select 'input[type=checkbox][value=2][disabled=disabled]'
-  end
-
-  test 'collection check boxes accepts a proc to disabled items' do
-    collection = (1..3).map{|i| [i, "Category #{i}"] }
-    with_collection_check_boxes :user, :category_ids, collection, :first, :last, :disabled => proc { |i| i.first == 1 }
-
-    assert_select 'input[type=checkbox][value=1][disabled=disabled]'
-    assert_no_select 'input[type=checkbox][value=3][disabled=disabled]'
-    assert_no_select 'input[type=checkbox][value=2][disabled=disabled]'
-  end
-
-  test 'collection check boxes accepts html options' do
-    collection = [[1, 'Category 1'], [2, 'Category 2']]
-    with_collection_check_boxes :user, :category_ids, collection, :first, :last, {}, :class => 'check'
-
-    assert_select 'input.check[type=checkbox][value=1]'
-    assert_select 'input.check[type=checkbox][value=2]'
-  end
-
-  test 'collection check boxes with fields for' do
-    collection = [Category.new(1, 'Category 1'), Category.new(2, 'Category 2')]
-    @output_buffer = fields_for(:post) do |p|
-      p.collection_check_boxes :category_ids, collection, :id, :name
-    end
-
-    assert_select 'input#post_category_ids_1[type=checkbox][value=1]'
-    assert_select 'input#post_category_ids_2[type=checkbox][value=2]'
-
-    assert_select 'label[for=post_category_ids_1]', 'Category 1'
-    assert_select 'label[for=post_category_ids_2]', 'Category 2'
-  end
-
-  test 'collection check boxes does not wrap input inside the label' do
-    with_collection_check_boxes :user, :active, [true, false], :to_s, :to_s
-
-    assert_select 'input[type=checkbox] + label'
-    assert_no_select 'label input'
-  end
-
-  test 'collection check boxes accepts a block to render the label as check box wrapper' do
-    with_collection_check_boxes :user, :active, [true, false], :to_s, :to_s do |b|
-      b.label { b.check_box }
-    end
-
-    assert_select 'label[for=user_active_true] > input#user_active_true[type=checkbox]'
-    assert_select 'label[for=user_active_false] > input#user_active_false[type=checkbox]'
-  end
-
-  test 'collection check boxes accepts a block to change the order of label and check box' do
-    with_collection_check_boxes :user, :active, [true, false], :to_s, :to_s do |b|
-      b.label + b.check_box
-    end
-
-    assert_select 'label[for=user_active_true] + input#user_active_true[type=checkbox]'
-    assert_select 'label[for=user_active_false] + input#user_active_false[type=checkbox]'
-  end
-
-  test 'collection check boxes with block helpers accept extra html options' do
-    with_collection_check_boxes :user, :active, [true, false], :to_s, :to_s do |b|
-      b.label(:class => "check_box") + b.check_box(:class => "check_box")
-    end
-
-    assert_select 'label.check_box[for=user_active_true] + input#user_active_true.check_box[type=checkbox]'
-    assert_select 'label.check_box[for=user_active_false] + input#user_active_false.check_box[type=checkbox]'
-  end
-
-  test 'collection check boxes with block helpers allows access to current text and value' do
-    with_collection_check_boxes :user, :active, [true, false], :to_s, :to_s do |b|
-      b.label(:"data-value" => b.value) { b.check_box + b.text }
-    end
-
-    assert_select 'label[for=user_active_true][data-value=true]', 'true' do
-      assert_select 'input#user_active_true[type=checkbox]'
-    end
-    assert_select 'label[for=user_active_false][data-value=false]', 'false' do
-      assert_select 'input#user_active_false[type=checkbox]'
-    end
-  end
-
-  test 'collection check boxes with block helpers allows access to the current object item in the collection to access extra properties' do
-    with_collection_check_boxes :user, :active, [true, false], :to_s, :to_s do |b|
-      b.label(:class => b.object) { b.check_box + b.text }
-    end
-
-    assert_select 'label.true[for=user_active_true]', 'true' do
-      assert_select 'input#user_active_true[type=checkbox]'
-    end
-    assert_select 'label.false[for=user_active_false]', 'false' do
-      assert_select 'input#user_active_false[type=checkbox]'
-    end
-  end
-end
diff --git a/actionpack/test/template/form_helper_test.rb b/actionpack/test/template/form_helper_test.rb
deleted file mode 100644
index 1ff320224d..0000000000
--- a/actionpack/test/template/form_helper_test.rb
+++ /dev/null
@@ -1,2959 +0,0 @@
-require 'abstract_unit'
-require 'controller/fake_models'
-
-class FormHelperTest < ActionView::TestCase
-  include RenderERBUtils
-
-  tests ActionView::Helpers::FormHelper
-
-  def form_for(*)
-    @output_buffer = super
-  end
-
-  def setup
-    super
-
-    # Create "label" locale for testing I18n label helpers
-    I18n.backend.store_translations 'label', {
-      activemodel: {
-        attributes: {
-          post: {
-            cost: "Total cost"
-          }
-        }
-      },
-      helpers: {
-        label: {
-          post: {
-            body: "Write entire text here",
-            color: {
-              red: "Rojo"
-            },
-            comments: {
-              body: "Write body here"
-            }
-          },
-          tag: {
-            value: "Tag"
-          }
-        }
-      }
-    }
-
-    # Create "submit" locale for testing I18n submit helpers
-    I18n.backend.store_translations 'submit', {
-      helpers: {
-        submit: {
-          create: 'Create %{model}',
-          update: 'Confirm %{model} changes',
-          submit: 'Save changes',
-          another_post: {
-            update: 'Update your %{model}'
-          }
-        }
-      }
-    }
-
-    @post = Post.new
-    @comment = Comment.new
-    def @post.errors()
-      Class.new {
-        def [](field); field == "author_name" ? ["can't be empty"] : [] end
-        def empty?() false end
-        def count() 1 end
-        def full_messages() ["Author name can't be empty"] end
-      }.new
-    end
-    def @post.to_key; [123]; end
-    def @post.id_before_type_cast; 123; end
-    def @post.to_param; '123'; end
-
-    @post.persisted   = true
-    @post.title       = "Hello World"
-    @post.author_name = ""
-    @post.body        = "Back to the hill and over it again!"
-    @post.secret      = 1
-    @post.written_on  = Date.new(2004, 6, 15)
-
-    @post.comments = []
-    @post.comments << @comment
-
-    @post.tags = []
-    @post.tags << Tag.new
-
-    @car = Car.new("#000FFF")
-  end
-
-  Routes = ActionDispatch::Routing::RouteSet.new
-  Routes.draw do
-    resources :posts do
-      resources :comments
-    end
-
-    namespace :admin do
-      resources :posts do
-        resources :comments
-      end
-    end
-
-    get "/foo", to: "controller#action"
-    root to: "main#index"
-  end
-
-  def _routes
-    Routes
-  end
-
-  include Routes.url_helpers
-
-  def url_for(object)
-    @url_for_options = object
-
-    if object.is_a?(Hash) && object[:use_route].blank? && object[:controller].blank?
-      object.merge!(controller: "main", action: "index")
-    end
-
-    super
-  end
-
-  class FooTag < ActionView::Helpers::Tags::Base
-    def initialize; end
-  end
-
-  def test_tags_base_child_without_render_method
-    assert_raise(NotImplementedError) { FooTag.new.render }
-  end
-
-  def test_label
-    assert_dom_equal('<label for="post_title">Title</label>', label("post", "title"))
-    assert_dom_equal(
-      '<label for="post_title">The title goes here</label>',
-      label("post", "title", "The title goes here")
-    )
-    assert_dom_equal(
-      '<label class="title_label" for="post_title">Title</label>',
-      label("post", "title", nil, class: 'title_label')
-    )
-    assert_dom_equal('<label for="post_secret">Secret?</label>', label("post", "secret?"))
-  end
-
-  def test_label_with_symbols
-    assert_dom_equal('<label for="post_title">Title</label>', label(:post, :title))
-    assert_dom_equal('<label for="post_secret">Secret?</label>', label(:post, :secret?))
-  end
-
-  def test_label_with_locales_strings
-    old_locale, I18n.locale = I18n.locale, :label
-    assert_dom_equal('<label for="post_body">Write entire text here</label>', label("post", "body"))
-  ensure
-    I18n.locale = old_locale
-  end
-
-  def test_label_with_human_attribute_name
-    old_locale, I18n.locale = I18n.locale, :label
-    assert_dom_equal('<label for="post_cost">Total cost</label>', label(:post, :cost))
-  ensure
-    I18n.locale = old_locale
-  end
-
-  def test_label_with_locales_symbols
-    old_locale, I18n.locale = I18n.locale, :label
-    assert_dom_equal('<label for="post_body">Write entire text here</label>', label(:post, :body))
-  ensure
-    I18n.locale = old_locale
-  end
-
-  def test_label_with_locales_and_options
-    old_locale, I18n.locale = I18n.locale, :label
-    assert_dom_equal(
-      '<label for="post_body" class="post_body">Write entire text here</label>',
-      label(:post, :body, class: "post_body")
-    )
-  ensure
-    I18n.locale = old_locale
-  end
-
-  def test_label_with_locales_and_value
-    old_locale, I18n.locale = I18n.locale, :label
-    assert_dom_equal('<label for="post_color_red">Rojo</label>', label(:post, :color, value: "red"))
-  ensure
-    I18n.locale = old_locale
-  end
-
-  def test_label_with_locales_and_nested_attributes
-    old_locale, I18n.locale = I18n.locale, :label
-    form_for(@post, html: { id: 'create-post' }) do |f|
-      f.fields_for(:comments) do |cf|
-        concat cf.label(:body)
-      end
-    end
-
-    expected = whole_form("/posts/123", "create-post", "edit_post", method: "patch") do
-      '<label for="post_comments_attributes_0_body">Write body here</label>'
-    end
-
-    assert_dom_equal expected, output_buffer
-  ensure
-    I18n.locale = old_locale
-  end
-
-  def test_label_with_locales_fallback_and_nested_attributes
-    old_locale, I18n.locale = I18n.locale, :label
-    form_for(@post, html: { id: 'create-post' }) do |f|
-      f.fields_for(:tags) do |cf|
-        concat cf.label(:value)
-      end
-    end
-
-    expected = whole_form("/posts/123", "create-post", "edit_post", method: "patch") do
-      '<label for="post_tags_attributes_0_value">Tag</label>'
-    end
-
-    assert_dom_equal expected, output_buffer
-  ensure
-    I18n.locale = old_locale
-  end
-
-  def test_label_with_for_attribute_as_symbol
-    assert_dom_equal('<label for="my_for">Title</label>', label(:post, :title, nil, for: "my_for"))
-  end
-
-  def test_label_with_for_attribute_as_string
-    assert_dom_equal('<label for="my_for">Title</label>', label(:post, :title, nil, "for" => "my_for"))
-  end
-
-  def test_label_does_not_generate_for_attribute_when_given_nil
-    assert_dom_equal('<label>Title</label>', label(:post, :title, for: nil))
-  end
-
-  def test_label_with_id_attribute_as_symbol
-    assert_dom_equal(
-      '<label for="post_title" id="my_id">Title</label>',
-      label(:post, :title, nil, id: "my_id")
-    )
-  end
-
-  def test_label_with_id_attribute_as_string
-    assert_dom_equal(
-      '<label for="post_title" id="my_id">Title</label>',
-      label(:post, :title, nil, "id" => "my_id")
-    )
-  end
-
-  def test_label_with_for_and_id_attributes_as_symbol
-    assert_dom_equal(
-      '<label for="my_for" id="my_id">Title</label>',
-      label(:post, :title, nil, for: "my_for", id: "my_id")
-    )
-  end
-
-  def test_label_with_for_and_id_attributes_as_string
-    assert_dom_equal(
-      '<label for="my_for" id="my_id">Title</label>',
-      label(:post, :title, nil, "for" => "my_for", "id" => "my_id")
-    )
-  end
-
-  def test_label_for_radio_buttons_with_value
-    assert_dom_equal(
-      '<label for="post_title_great_title">The title goes here</label>',
-      label("post", "title", "The title goes here", value: "great_title")
-    )
-    assert_dom_equal(
-      '<label for="post_title_great_title">The title goes here</label>',
-      label("post", "title", "The title goes here", value: "great title")
-    )
-  end
-
-  def test_label_with_block
-    assert_dom_equal(
-      '<label for="post_title">The title, please:</label>',
-      label(:post, :title) { "The title, please:" }
-    )
-  end
-
-  def test_label_with_block_and_options
-    assert_dom_equal(
-      '<label for="my_for">The title, please:</label>',
-      label(:post, :title, "for" => "my_for") { "The title, please:" }
-    )
-  end
-
-  def test_label_with_block_in_erb
-    assert_equal(
-      %{<label for="post_message">\n  Message\n  <input id="post_message" name="post[message]" type="text" />\n</label>},
-      view.render("test/label_with_block")
-    )
-  end
-
-  def test_text_field
-    assert_dom_equal(
-      '<input id="post_title" name="post[title]" type="text" value="Hello World" />',
-      text_field("post", "title")
-    )
-    assert_dom_equal(
-      '<input id="post_title" name="post[title]" type="password" />',
-      password_field("post", "title")
-    )
-    assert_dom_equal(
-      '<input id="post_title" name="post[title]" type="password" value="Hello World" />',
-      password_field("post", "title", value: @post.title)
-    )
-    assert_dom_equal(
-      '<input id="person_name" name="person[name]" type="password" />',
-      password_field("person", "name")
-    )
-  end
-
-  def test_text_field_with_escapes
-    @post.title = "<b>Hello World</b>"
-    assert_dom_equal(
-      '<input id="post_title" name="post[title]" type="text" value="&lt;b&gt;Hello World&lt;/b&gt;" />',
-      text_field("post", "title")
-    )
-  end
-
-  def test_text_field_with_html_entities
-    @post.title = "The HTML Entity for & is &amp;"
-    assert_dom_equal(
-      '<input id="post_title" name="post[title]" type="text" value="The HTML Entity for &amp; is &amp;amp;" />',
-      text_field("post", "title")
-    )
-  end
-
-  def test_text_field_with_options
-    expected = '<input id="post_title" name="post[title]" size="35" type="text" value="Hello World" />'
-    assert_dom_equal expected, text_field("post", "title", "size" => 35)
-    assert_dom_equal expected, text_field("post", "title", size: 35)
-  end
-
-  def test_text_field_assuming_size
-    expected = '<input id="post_title" maxlength="35" name="post[title]" size="35" type="text" value="Hello World" />'
-    assert_dom_equal expected, text_field("post", "title", "maxlength" => 35)
-    assert_dom_equal expected, text_field("post", "title", maxlength: 35)
-  end
-
-  def test_text_field_removing_size
-    expected = '<input id="post_title" maxlength="35" name="post[title]" type="text" value="Hello World" />'
-    assert_dom_equal expected, text_field("post", "title", "maxlength" => 35, "size" => nil)
-    assert_dom_equal expected, text_field("post", "title", maxlength: 35, size: nil)
-  end
-
-  def test_text_field_with_nil_value
-    expected = '<input id="post_title" name="post[title]" type="text" />'
-    assert_dom_equal expected, text_field("post", "title", value: nil)
-  end
-
-  def test_text_field_with_nil_name
-    expected = '<input id="post_title" type="text" value="Hello World" />'
-    assert_dom_equal expected, text_field("post", "title", name: nil)
-  end
-
-  def test_text_field_doesnt_change_param_values
-    object_name = 'post[]'
-    expected = '<input id="post_123_title" name="post[123][title]" type="text" value="Hello World" />'
-    assert_equal expected, text_field(object_name, "title")
-    assert_equal object_name, "post[]"
-  end
-
-  def test_file_field_has_no_size
-    expected = '<input id="user_avatar" name="user[avatar]" type="file" />'
-    assert_dom_equal expected, file_field("user", "avatar")
-  end
-
-  def test_file_field_with_multiple_behavior
-    expected = '<input id="import_file" multiple="multiple" name="import[file][]" type="file" />'
-    assert_dom_equal expected, file_field("import", "file", :multiple => true)
-  end
-
-  def test_file_field_with_multiple_behavior_and_explicit_name
-    expected = '<input id="import_file" multiple="multiple" name="custom" type="file" />'
-    assert_dom_equal expected, file_field("import", "file", :multiple => true, :name => "custom")
-  end
-
-  def test_hidden_field
-    assert_dom_equal(
-      '<input id="post_title" name="post[title]" type="hidden" value="Hello World" />',
-      hidden_field("post", "title")
-    )
-    assert_dom_equal(
-      '<input id="post_secret" name="post[secret]" type="hidden" value="1" />',
-      hidden_field("post", "secret?")
-    )
-  end
-
-  def test_hidden_field_with_escapes
-    @post.title = "<b>Hello World</b>"
-    assert_dom_equal(
-      '<input id="post_title" name="post[title]" type="hidden" value="&lt;b&gt;Hello World&lt;/b&gt;" />',
-      hidden_field("post", "title")
-    )
-  end
-
-  def test_hidden_field_with_nil_value
-    expected = '<input id="post_title" name="post[title]" type="hidden" />'
-    assert_dom_equal expected, hidden_field("post", "title", value: nil)
-  end
-
-  def test_hidden_field_with_options
-    assert_dom_equal(
-      '<input id="post_title" name="post[title]" type="hidden" value="Something Else" />',
-      hidden_field("post", "title", value: "Something Else")
-    )
-  end
-
-  def test_text_field_with_custom_type
-    assert_dom_equal(
-      '<input id="user_email" name="user[email]" type="email" />',
-      text_field("user", "email", type: "email")
-    )
-  end
-
-  def test_check_box_is_html_safe
-    assert check_box("post", "secret").html_safe?
-  end
-
-  def test_check_box_checked_if_object_value_is_same_that_check_value
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret")
-    )
-  end
-
-  def test_check_box_not_checked_if_object_value_is_same_that_unchecked_value
-    @post.secret = 0
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" /><input id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret")
-    )
-  end
-
-  def test_check_box_checked_if_option_checked_is_present
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret", "checked"=>"checked")
-    )
-  end
-
-  def test_check_box_checked_if_object_value_is_true
-    @post.secret = true
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret")
-    )
-
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret?")
-    )
-  end
-
-  def test_check_box_checked_if_object_value_includes_checked_value
-    @post.secret = ['0']
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" /><input id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret")
-    )
-
-    @post.secret = ['1']
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret")
-    )
-
-    @post.secret = Set.new(['1'])
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret")
-    )
-  end
-
-  def test_check_box_with_include_hidden_false
-    @post.secret = false
-    assert_dom_equal(
-      '<input id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret", include_hidden: false)
-    )
-  end
-
-  def test_check_box_with_explicit_checked_and_unchecked_values_when_object_value_is_string
-    @post.secret = "on"
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="off" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="on" />',
-      check_box("post", "secret", {}, "on", "off")
-    )
-
-    @post.secret = "off"
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="off" /><input id="post_secret" name="post[secret]" type="checkbox" value="on" />',
-      check_box("post", "secret", {}, "on", "off")
-    )
-  end
-
-  def test_check_box_with_explicit_checked_and_unchecked_values_when_object_value_is_boolean
-    @post.secret = false
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="true" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="false" />',
-      check_box("post", "secret", {}, false, true)
-    )
-
-    @post.secret = true
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="true" /><input id="post_secret" name="post[secret]" type="checkbox" value="false" />',
-      check_box("post", "secret", {}, false, true)
-    )
-  end
-
-  def test_check_box_with_explicit_checked_and_unchecked_values_when_object_value_is_integer
-    @post.secret = 0
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="1" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="0" />',
-      check_box("post", "secret", {}, 0, 1)
-    )
-
-    @post.secret = 1
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="1" /><input id="post_secret" name="post[secret]" type="checkbox" value="0" />',
-      check_box("post", "secret", {}, 0, 1)
-    )
-
-    @post.secret = 2
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="1" /><input id="post_secret" name="post[secret]" type="checkbox" value="0" />',
-      check_box("post", "secret", {}, 0, 1)
-    )
-  end
-
-  def test_check_box_with_explicit_checked_and_unchecked_values_when_object_value_is_float
-    @post.secret = 0.0
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="1" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="0" />',
-      check_box("post", "secret", {}, 0, 1)
-    )
-
-    @post.secret = 1.1
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="1" /><input id="post_secret" name="post[secret]" type="checkbox" value="0" />',
-      check_box("post", "secret", {}, 0, 1)
-    )
-
-    @post.secret = 2.2
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="1" /><input id="post_secret" name="post[secret]" type="checkbox" value="0" />',
-      check_box("post", "secret", {}, 0, 1)
-    )
-  end
-
-  def test_check_box_with_explicit_checked_and_unchecked_values_when_object_value_is_big_decimal
-    @post.secret = BigDecimal.new(0)
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="1" /><input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="0" />',
-      check_box("post", "secret", {}, 0, 1)
-    )
-
-    @post.secret = BigDecimal.new(1)
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="1" /><input id="post_secret" name="post[secret]" type="checkbox" value="0" />',
-      check_box("post", "secret", {}, 0, 1)
-    )
-
-    @post.secret = BigDecimal.new(2.2, 1)
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="1" /><input id="post_secret" name="post[secret]" type="checkbox" value="0" />',
-      check_box("post", "secret", {}, 0, 1)
-    )
-  end
-
-  def test_check_box_with_nil_unchecked_value
-    @post.secret = "on"
-    assert_dom_equal(
-      '<input checked="checked" id="post_secret" name="post[secret]" type="checkbox" value="on" />',
-      check_box("post", "secret", {}, "on", nil)
-    )
-  end
-
-  def test_check_box_with_nil_unchecked_value_is_html_safe
-    assert check_box("post", "secret", {}, "on", nil).html_safe?
-  end
-
-  def test_check_box_with_multiple_behavior
-    @post.comment_ids = [2,3]
-    assert_dom_equal(
-      '<input name="post[comment_ids][]" type="hidden" value="0" /><input id="post_comment_ids_1" name="post[comment_ids][]" type="checkbox" value="1" />',
-      check_box("post", "comment_ids", { multiple: true }, 1)
-    )
-    assert_dom_equal(
-      '<input name="post[comment_ids][]" type="hidden" value="0" /><input checked="checked" id="post_comment_ids_3" name="post[comment_ids][]" type="checkbox" value="3" />',
-      check_box("post", "comment_ids", { multiple: true }, 3)
-    )
-  end
-
-  def test_check_box_with_multiple_behavior_and_index
-    @post.comment_ids = [2,3]
-    assert_dom_equal(
-      '<input name="post[foo][comment_ids][]" type="hidden" value="0" /><input id="post_foo_comment_ids_1" name="post[foo][comment_ids][]" type="checkbox" value="1" />',
-      check_box("post", "comment_ids", { multiple: true, index: "foo" }, 1)
-    )
-    assert_dom_equal(
-      '<input name="post[bar][comment_ids][]" type="hidden" value="0" /><input checked="checked" id="post_bar_comment_ids_3" name="post[bar][comment_ids][]" type="checkbox" value="3" />',
-      check_box("post", "comment_ids", { multiple: true, index: "bar" }, 3)
-    )
-
-  end
-
-  def test_checkbox_disabled_disables_hidden_field
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" disabled="disabled"/><input checked="checked" disabled="disabled" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret", { disabled: true })
-    )
-  end
-
-  def test_checkbox_form_html5_attribute
-    assert_dom_equal(
-      '<input form="new_form" name="post[secret]" type="hidden" value="0" /><input checked="checked" form="new_form" id="post_secret" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret", form: "new_form")
-    )
-  end
-
-  def test_radio_button
-    assert_dom_equal('<input checked="checked" id="post_title_hello_world" name="post[title]" type="radio" value="Hello World" />',
-      radio_button("post", "title", "Hello World")
-    )
-    assert_dom_equal('<input id="post_title_goodbye_world" name="post[title]" type="radio" value="Goodbye World" />',
-      radio_button("post", "title", "Goodbye World")
-    )
-    assert_dom_equal('<input id="item_subobject_title_inside_world" name="item[subobject][title]" type="radio" value="inside world"/>',
-      radio_button("item[subobject]", "title", "inside world")
-    )
-  end
-
-  def test_radio_button_is_checked_with_integers
-    assert_dom_equal('<input checked="checked" id="post_secret_1" name="post[secret]" type="radio" value="1" />',
-      radio_button("post", "secret", "1")
-   )
-  end
-
-  def test_radio_button_with_negative_integer_value
-    assert_dom_equal('<input id="post_secret_-1" name="post[secret]" type="radio" value="-1" />',
-      radio_button("post", "secret", "-1"))
-  end
-
-  def test_radio_button_respects_passed_in_id
-     assert_dom_equal('<input checked="checked" id="foo" name="post[secret]" type="radio" value="1" />',
-       radio_button("post", "secret", "1", id: "foo")
-    )
-  end
-
-  def test_radio_button_with_booleans
-    assert_dom_equal('<input id="post_secret_true" name="post[secret]" type="radio" value="true" />',
-      radio_button("post", "secret", true)
-    )
-
-    assert_dom_equal('<input id="post_secret_false" name="post[secret]" type="radio" value="false" />',
-      radio_button("post", "secret", false)
-    )
-  end
-
-  def test_text_area
-    assert_dom_equal(
-      %{<textarea id="post_body" name="post[body]">\nBack to the hill and over it again!</textarea>},
-      text_area("post", "body")
-    )
-  end
-
-  def test_text_area_with_escapes
-    @post.body = "Back to <i>the</i> hill and over it again!"
-    assert_dom_equal(
-      %{<textarea id="post_body" name="post[body]">\nBack to &lt;i&gt;the&lt;/i&gt; hill and over it again!</textarea>},
-      text_area("post", "body")
-    )
-  end
-
-  def test_text_area_with_alternate_value
-    assert_dom_equal(
-      %{<textarea id="post_body" name="post[body]">\nTesting alternate values.</textarea>},
-      text_area("post", "body", value: "Testing alternate values.")
-    )
-  end
-
-  def test_text_area_with_html_entities
-    @post.body = "The HTML Entity for & is &amp;"
-    assert_dom_equal(
-      %{<textarea id="post_body" name="post[body]">\nThe HTML Entity for &amp; is &amp;amp;</textarea>},
-      text_area("post", "body")
-    )
-  end
-
-  def test_text_area_with_size_option
-    assert_dom_equal(
-      %{<textarea cols="183" id="post_body" name="post[body]" rows="820">\nBack to the hill and over it again!</textarea>},
-      text_area("post", "body", size: "183x820")
-    )
-  end
-
-  def test_color_field_with_valid_hex_color_string
-    expected = %{<input id="car_color" name="car[color]" type="color" value="#000fff" />}
-    assert_dom_equal(expected, color_field("car", "color"))
-  end
-
-  def test_color_field_with_invalid_hex_color_string
-    expected = %{<input id="car_color" name="car[color]" type="color" value="#000000" />}
-    @car.color = "#1234TR"
-    assert_dom_equal(expected, color_field("car", "color"))
-  end
-
-  def test_search_field
-    expected = %{<input id="contact_notes_query" name="contact[notes_query]" type="search" />}
-    assert_dom_equal(expected, search_field("contact", "notes_query"))
-  end
-
-  def test_telephone_field
-    expected = %{<input id="user_cell" name="user[cell]" type="tel" />}
-    assert_dom_equal(expected, telephone_field("user", "cell"))
-  end
-
-  def test_date_field
-    expected = %{<input id="post_written_on" name="post[written_on]" type="date" value="2004-06-15" />}
-    assert_dom_equal(expected, date_field("post", "written_on"))
-  end
-
-  def test_date_field_with_datetime_value
-    expected = %{<input id="post_written_on" name="post[written_on]" type="date" value="2004-06-15" />}
-    @post.written_on = DateTime.new(2004, 6, 15, 1, 2, 3)
-    assert_dom_equal(expected, date_field("post", "written_on"))
-  end
-
-  def test_date_field_with_extra_attrs
-    expected = %{<input id="post_written_on" step="2" max="2010-08-15" min="2000-06-15" name="post[written_on]" type="date" value="2004-06-15" />}
-    @post.written_on = DateTime.new(2004, 6, 15)
-    min_value = DateTime.new(2000, 6, 15)
-    max_value = DateTime.new(2010, 8, 15)
-    step = 2
-    assert_dom_equal(expected, date_field("post", "written_on", min: min_value, max: max_value, step: step))
-  end
-
-  def test_date_field_with_timewithzone_value
-    previous_time_zone, Time.zone = Time.zone, 'UTC'
-    expected = %{<input id="post_written_on" name="post[written_on]" type="date" value="2004-06-15" />}
-    @post.written_on = Time.zone.parse('2004-06-15 15:30:45')
-    assert_dom_equal(expected, date_field("post", "written_on"))
-  ensure
-    Time.zone = previous_time_zone
-  end
-
-  def test_date_field_with_nil_value
-    expected = %{<input id="post_written_on" name="post[written_on]" type="date" />}
-    @post.written_on = nil
-    assert_dom_equal(expected, date_field("post", "written_on"))
-  end
-
-  def test_time_field
-    expected = %{<input id="post_written_on" name="post[written_on]" type="time" value="00:00:00.000" />}
-    assert_dom_equal(expected, time_field("post", "written_on"))
-  end
-
-  def test_time_field_with_datetime_value
-    expected = %{<input id="post_written_on" name="post[written_on]" type="time" value="01:02:03.000" />}
-    @post.written_on = DateTime.new(2004, 6, 15, 1, 2, 3)
-    assert_dom_equal(expected, time_field("post", "written_on"))
-  end
-
-  def test_time_field_with_extra_attrs
-    expected = %{<input id="post_written_on" step="60" max="10:25:00.000" min="20:45:30.000" name="post[written_on]" type="time" value="01:02:03.000" />}
-    @post.written_on = DateTime.new(2004, 6, 15, 1, 2, 3)
-    min_value = DateTime.new(2000, 6, 15, 20, 45, 30)
-    max_value = DateTime.new(2010, 8, 15, 10, 25, 00)
-    step = 60
-    assert_dom_equal(expected, time_field("post", "written_on", min: min_value, max: max_value, step: step))
-  end
-
-  def test_time_field_with_timewithzone_value
-    previous_time_zone, Time.zone = Time.zone, 'UTC'
-    expected = %{<input id="post_written_on" name="post[written_on]" type="time" value="01:02:03.000" />}
-    @post.written_on = Time.zone.parse('2004-06-15 01:02:03')
-    assert_dom_equal(expected, time_field("post", "written_on"))
-  ensure
-    Time.zone = previous_time_zone
-  end
-
-  def test_time_field_with_nil_value
-    expected = %{<input id="post_written_on" name="post[written_on]" type="time" />}
-    @post.written_on = nil
-    assert_dom_equal(expected, time_field("post", "written_on"))
-  end
-
-  def test_datetime_field
-    expected = %{<input id="post_written_on" name="post[written_on]" type="datetime" value="2004-06-15T00:00:00.000+0000" />}
-    assert_dom_equal(expected, datetime_field("post", "written_on"))
-  end
-
-  def test_datetime_field_with_datetime_value
-    expected = %{<input id="post_written_on" name="post[written_on]" type="datetime" value="2004-06-15T01:02:03.000+0000" />}
-    @post.written_on = DateTime.new(2004, 6, 15, 1, 2, 3)
-    assert_dom_equal(expected, datetime_field("post", "written_on"))
-  end
-
-  def test_datetime_field_with_extra_attrs
-    expected = %{<input id="post_written_on" step="60" max="2010-08-15T10:25:00.000+0000" min="2000-06-15T20:45:30.000+0000" name="post[written_on]" type="datetime" value="2004-06-15T01:02:03.000+0000" />}
-    @post.written_on = DateTime.new(2004, 6, 15, 1, 2, 3)
-    min_value = DateTime.new(2000, 6, 15, 20, 45, 30)
-    max_value = DateTime.new(2010, 8, 15, 10, 25, 00)
-    step = 60
-    assert_dom_equal(expected, datetime_field("post", "written_on", min: min_value, max: max_value, step: step))
-  end
-
-  def test_datetime_field_with_timewithzone_value
-    previous_time_zone, Time.zone = Time.zone, 'UTC'
-    expected = %{<input id="post_written_on" name="post[written_on]" type="datetime" value="2004-06-15T15:30:45.000+0000" />}
-    @post.written_on = Time.zone.parse('2004-06-15 15:30:45')
-    assert_dom_equal(expected, datetime_field("post", "written_on"))
-  ensure
-    Time.zone = previous_time_zone
-  end
-
-  def test_datetime_field_with_nil_value
-    expected = %{<input id="post_written_on" name="post[written_on]" type="datetime" />}
-    @post.written_on = nil
-    assert_dom_equal(expected, datetime_field("post", "written_on"))
-  end
-
-  def test_datetime_local_field
-    expected = %{<input id="post_written_on" name="post[written_on]" type="datetime-local" value="2004-06-15T00:00:00" />}
-    assert_dom_equal(expected, datetime_local_field("post", "written_on"))
-  end
-
-  def test_datetime_local_field_with_datetime_value
-    expected = %{<input id="post_written_on" name="post[written_on]" type="datetime-local" value="2004-06-15T01:02:03" />}
-    @post.written_on = DateTime.new(2004, 6, 15, 1, 2, 3)
-    assert_dom_equal(expected, datetime_local_field("post", "written_on"))
-  end
-
-  def test_datetime_local_field_with_extra_attrs
-    expected = %{<input id="post_written_on" step="60" max="2010-08-15T10:25:00" min="2000-06-15T20:45:30" name="post[written_on]" type="datetime-local" value="2004-06-15T01:02:03" />}
-    @post.written_on = DateTime.new(2004, 6, 15, 1, 2, 3)
-    min_value = DateTime.new(2000, 6, 15, 20, 45, 30)
-    max_value = DateTime.new(2010, 8, 15, 10, 25, 00)
-    step = 60
-    assert_dom_equal(expected, datetime_local_field("post", "written_on", min: min_value, max: max_value, step: step))
-  end
-
-  def test_datetime_local_field_with_timewithzone_value
-    previous_time_zone, Time.zone = Time.zone, 'UTC'
-    expected = %{<input id="post_written_on" name="post[written_on]" type="datetime-local" value="2004-06-15T15:30:45" />}
-    @post.written_on = Time.zone.parse('2004-06-15 15:30:45')
-    assert_dom_equal(expected, datetime_local_field("post", "written_on"))
-  ensure
-    Time.zone = previous_time_zone
-  end
-
-  def test_datetime_local_field_with_nil_value
-    expected = %{<input id="post_written_on" name="post[written_on]" type="datetime-local" />}
-    @post.written_on = nil
-    assert_dom_equal(expected, datetime_local_field("post", "written_on"))
-  end
-
-  def test_month_field
-    expected = %{<input id="post_written_on" name="post[written_on]" type="month" value="2004-06" />}
-    assert_dom_equal(expected, month_field("post", "written_on"))
-  end
-
-  def test_month_field_with_nil_value
-    expected = %{<input id="post_written_on" name="post[written_on]" type="month" />}
-    @post.written_on = nil
-    assert_dom_equal(expected, month_field("post", "written_on"))
-  end
-
-  def test_month_field_with_datetime_value
-    expected = %{<input id="post_written_on" name="post[written_on]" type="month" value="2004-06" />}
-    @post.written_on = DateTime.new(2004, 6, 15, 1, 2, 3)
-    assert_dom_equal(expected, month_field("post", "written_on"))
-  end
-
-  def test_month_field_with_extra_attrs
-    expected = %{<input id="post_written_on" step="2" max="2010-12" min="2000-02" name="post[written_on]" type="month" value="2004-06" />}
-    @post.written_on = DateTime.new(2004, 6, 15, 1, 2, 3)
-    min_value = DateTime.new(2000, 2, 13)
-    max_value = DateTime.new(2010, 12, 23)
-    step = 2
-    assert_dom_equal(expected, month_field("post", "written_on", min: min_value, max: max_value, step: step))
-  end
-
-  def test_month_field_with_timewithzone_value
-    previous_time_zone, Time.zone = Time.zone, 'UTC'
-    expected = %{<input id="post_written_on" name="post[written_on]" type="month" value="2004-06" />}
-    @post.written_on = Time.zone.parse('2004-06-15 15:30:45')
-    assert_dom_equal(expected, month_field("post", "written_on"))
-  ensure
-    Time.zone = previous_time_zone
-  end
-
-  def test_week_field
-    expected = %{<input id="post_written_on" name="post[written_on]" type="week" value="2004-W24" />}
-    assert_dom_equal(expected, week_field("post", "written_on"))
-  end
-
-  def test_week_field_with_nil_value
-    expected = %{<input id="post_written_on" name="post[written_on]" type="week" />}
-    @post.written_on = nil
-    assert_dom_equal(expected, week_field("post", "written_on"))
-  end
-
-  def test_week_field_with_datetime_value
-    expected = %{<input id="post_written_on" name="post[written_on]" type="week" value="2004-W24" />}
-    @post.written_on = DateTime.new(2004, 6, 15, 1, 2, 3)
-    assert_dom_equal(expected, week_field("post", "written_on"))
-  end
-
-  def test_week_field_with_extra_attrs
-    expected = %{<input id="post_written_on" step="2" max="2010-W51" min="2000-W06" name="post[written_on]" type="week" value="2004-W24" />}
-    @post.written_on = DateTime.new(2004, 6, 15, 1, 2, 3)
-    min_value = DateTime.new(2000, 2, 13)
-    max_value = DateTime.new(2010, 12, 23)
-    step = 2
-    assert_dom_equal(expected, week_field("post", "written_on", min: min_value, max: max_value, step: step))
-  end
-
-  def test_week_field_with_timewithzone_value
-    previous_time_zone, Time.zone = Time.zone, 'UTC'
-    expected = %{<input id="post_written_on" name="post[written_on]" type="week" value="2004-W24" />}
-    @post.written_on = Time.zone.parse('2004-06-15 15:30:45')
-    assert_dom_equal(expected, week_field("post", "written_on"))
-  ensure
-    Time.zone = previous_time_zone
-  end
-
-  def test_url_field
-    expected = %{<input id="user_homepage" name="user[homepage]" type="url" />}
-    assert_dom_equal(expected, url_field("user", "homepage"))
-  end
-
-  def test_email_field
-    expected = %{<input id="user_address" name="user[address]" type="email" />}
-    assert_dom_equal(expected, email_field("user", "address"))
-  end
-
-  def test_number_field
-    expected = %{<input name="order[quantity]" max="9" id="order_quantity" type="number" min="1" />}
-    assert_dom_equal(expected, number_field("order", "quantity", in: 1...10))
-    expected = %{<input name="order[quantity]" size="30" max="9" id="order_quantity" type="number" min="1" />}
-    assert_dom_equal(expected, number_field("order", "quantity", size: 30, in: 1...10))
-  end
-
-  def test_range_input
-    expected = %{<input name="hifi[volume]" step="0.1" max="11" id="hifi_volume" type="range" min="0" />}
-    assert_dom_equal(expected, range_field("hifi", "volume", in: 0..11, step: 0.1))
-    expected = %{<input name="hifi[volume]" step="0.1" size="30" max="11" id="hifi_volume" type="range" min="0" />}
-    assert_dom_equal(expected, range_field("hifi", "volume", size: 30, in: 0..11, step: 0.1))
-  end
-
-  def test_explicit_name
-    assert_dom_equal(
-      '<input id="post_title" name="dont guess" type="text" value="Hello World" />',
-      text_field("post", "title", "name" => "dont guess")
-    )
-    assert_dom_equal(
-      %{<textarea id="post_body" name="really!">\nBack to the hill and over it again!</textarea>},
-      text_area("post", "body", "name" => "really!")
-    )
-    assert_dom_equal(
-      '<input name="i mean it" type="hidden" value="0" /><input checked="checked" id="post_secret" name="i mean it" type="checkbox" value="1" />',
-      check_box("post", "secret", "name" => "i mean it")
-    )
-    assert_dom_equal(
-      text_field("post", "title", "name" => "dont guess"),
-      text_field("post", "title", name: "dont guess")
-    )
-    assert_dom_equal(
-      text_area("post", "body", "name" => "really!"),
-      text_area("post", "body", name: "really!")
-    )
-    assert_dom_equal(
-      check_box("post", "secret", "name" => "i mean it"),
-      check_box("post", "secret", name: "i mean it")
-    )
-  end
-
-  def test_explicit_id
-    assert_dom_equal(
-      '<input id="dont guess" name="post[title]" type="text" value="Hello World" />',
-      text_field("post", "title", "id" => "dont guess")
-    )
-    assert_dom_equal(
-      %{<textarea id="really!" name="post[body]">\nBack to the hill and over it again!</textarea>},
-      text_area("post", "body", "id" => "really!")
-    )
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" /><input checked="checked" id="i mean it" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret", "id" => "i mean it")
-    )
-    assert_dom_equal(
-      text_field("post", "title", "id" => "dont guess"),
-      text_field("post", "title", id: "dont guess")
-    )
-    assert_dom_equal(
-      text_area("post", "body", "id" => "really!"),
-      text_area("post", "body", id: "really!")
-    )
-    assert_dom_equal(
-      check_box("post", "secret", "id" => "i mean it"),
-      check_box("post", "secret", id: "i mean it")
-    )
-  end
-
-  def test_nil_id
-    assert_dom_equal(
-      '<input name="post[title]" type="text" value="Hello World" />',
-      text_field("post", "title", "id" => nil)
-    )
-    assert_dom_equal(
-      %{<textarea name="post[body]">\nBack to the hill and over it again!</textarea>},
-      text_area("post", "body", "id" => nil)
-    )
-    assert_dom_equal(
-      '<input name="post[secret]" type="hidden" value="0" /><input checked="checked" name="post[secret]" type="checkbox" value="1" />',
-      check_box("post", "secret", "id" => nil)
-    )
-    assert_dom_equal(
-      '<input type="radio" name="post[secret]" value="0" />',
-      radio_button("post", "secret", "0", "id" => nil)
-    )
-    assert_dom_equal(
-      '<select name="post[secret]"></select>',
-      select("post", "secret", [], {}, "id" => nil)
-    )
-    assert_dom_equal(
-      text_field("post", "title", "id" => nil),
-      text_field("post", "title", id: nil)
-    )
-    assert_dom_equal(
-      text_area("post", "body", "id" => nil),
-      text_area("post", "body", id: nil)
-    )
-    assert_dom_equal(
-      check_box("post", "secret", "id" => nil),
-      check_box("post", "secret", id: nil)
-    )
-    assert_dom_equal(
-      radio_button("post", "secret", "0", "id" => nil),
-      radio_button("post", "secret", "0", id: nil)
-    )
-  end
-
-  def test_index
-    assert_dom_equal(
-      '<input name="post[5][title]" id="post_5_title" type="text" value="Hello World" />',
-      text_field("post", "title", "index" => 5)
-    )
-    assert_dom_equal(
-      %{<textarea name="post[5][body]" id="post_5_body">\nBack to the hill and over it again!</textarea>},
-      text_area("post", "body", "index" => 5)
-    )
-    assert_dom_equal(
-      '<input name="post[5][secret]" type="hidden" value="0" /><input checked="checked" name="post[5][secret]" type="checkbox" value="1" id="post_5_secret" />',
-      check_box("post", "secret", "index" => 5)
-    )
-    assert_dom_equal(
-      text_field("post", "title", "index" => 5),
-      text_field("post", "title", "index" => 5)
-    )
-    assert_dom_equal(
-      text_area("post", "body", "index" => 5),
-      text_area("post", "body", "index" => 5)
-    )
-    assert_dom_equal(
-      check_box("post", "secret", "index" => 5),
-      check_box("post", "secret", "index" => 5)
-    )
-  end
-
-  def test_index_with_nil_id
-    assert_dom_equal(
-      '<input name="post[5][title]" type="text" value="Hello World" />',
-      text_field("post", "title", "index" => 5, 'id' => nil)
-    )
-    assert_dom_equal(
-      %{<textarea name="post[5][body]">\nBack to the hill and over it again!</textarea>},
-      text_area("post", "body", "index" => 5, 'id' => nil)
-    )
-    assert_dom_equal(
-      '<input name="post[5][secret]" type="hidden" value="0" /><input checked="checked" name="post[5][secret]" type="checkbox" value="1" />',
-      check_box("post", "secret", "index" => 5, 'id' => nil)
-    )
-    assert_dom_equal(
-      text_field("post", "title", "index" => 5, 'id' => nil),
-      text_field("post", "title", index: 5, id: nil)
-    )
-    assert_dom_equal(
-      text_area("post", "body", "index" => 5, 'id' => nil),
-      text_area("post", "body", index: 5, id: nil)
-    )
-    assert_dom_equal(
-      check_box("post", "secret", "index" => 5, 'id' => nil),
-      check_box("post", "secret", index: 5, id: nil)
-    )
-  end
-
-  def test_auto_index
-    pid = 123
-    assert_dom_equal(
-      %{<label for="post_#{pid}_title">Title</label>},
-      label("post[]", "title")
-    )
-    assert_dom_equal(
-      %{<input id="post_#{pid}_title" name="post[#{pid}][title]" type="text" value="Hello World" />},
-      text_field("post[]","title")
-    )
-    assert_dom_equal(
-      %{<textarea id="post_#{pid}_body" name="post[#{pid}][body]">\nBack to the hill and over it again!</textarea>},
-      text_area("post[]", "body")
-    )
-    assert_dom_equal(
-      %{<input name="post[#{pid}][secret]" type="hidden" value="0" /><input checked="checked" id="post_#{pid}_secret" name="post[#{pid}][secret]" type="checkbox" value="1" />},
-      check_box("post[]", "secret")
-    )
-   assert_dom_equal(
-      %{<input checked="checked" id="post_#{pid}_title_hello_world" name="post[#{pid}][title]" type="radio" value="Hello World" />},
-      radio_button("post[]", "title", "Hello World")
-    )
-    assert_dom_equal(
-      %{<input id="post_#{pid}_title_goodbye_world" name="post[#{pid}][title]" type="radio" value="Goodbye World" />},
-      radio_button("post[]", "title", "Goodbye World")
-    )
-  end
-
-  def test_auto_index_with_nil_id
-    pid = 123
-    assert_dom_equal(
-      %{<input name="post[#{pid}][title]" type="text" value="Hello World" />},
-      text_field("post[]", "title", id: nil)
-    )
-    assert_dom_equal(
-      %{<textarea name="post[#{pid}][body]">\nBack to the hill and over it again!</textarea>},
-      text_area("post[]", "body", id: nil)
-    )
-    assert_dom_equal(
-      %{<input name="post[#{pid}][secret]" type="hidden" value="0" /><input checked="checked" name="post[#{pid}][secret]" type="checkbox" value="1" />},
-      check_box("post[]", "secret", id: nil)
-    )
-   assert_dom_equal(
-     %{<input checked="checked" name="post[#{pid}][title]" type="radio" value="Hello World" />},
-      radio_button("post[]", "title", "Hello World", id: nil)
-    )
-    assert_dom_equal(
-      %{<input name="post[#{pid}][title]" type="radio" value="Goodbye World" />},
-      radio_button("post[]", "title", "Goodbye World", id: nil)
-    )
-  end
-
-  def test_form_for_requires_block
-    assert_raises(ArgumentError) do
-      form_for(:post, @post, html: { id: 'create-post' })
-    end
-  end
-
-  def test_form_for_requires_arguments
-    error = assert_raises(ArgumentError) do
-      form_for(nil, html: { id: 'create-post' }) do
-      end
-    end
-    assert_equal "First argument in form cannot contain nil or be empty", error.message
-
-    error = assert_raises(ArgumentError) do
-      form_for([nil, nil], html: { id: 'create-post' }) do
-      end
-    end
-    assert_equal "First argument in form cannot contain nil or be empty", error.message
-  end
-
-  def test_form_for
-    form_for(@post, html: { id: 'create-post' }) do |f|
-      concat f.label(:title) { "The Title" }
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
-      concat f.submit('Create post')
-      concat f.button('Create post')
-      concat f.button {
-        concat content_tag(:span, 'Create post')
-      }
-    end
-
-    expected = whole_form("/posts/123", "create-post", "edit_post", method: "patch") do
-      "<label for='post_title'>The Title</label>" +
-      "<input name='post[title]' type='text' id='post_title' value='Hello World' />" +
-      "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" +
-      "<input name='post[secret]' type='hidden' value='0' />" +
-      "<input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' />" +
-      "<input name='commit' type='submit' value='Create post' />" +
-      "<button name='button' type='submit'>Create post</button>" +
-      "<button name='button' type='submit'><span>Create post</span></button>"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_collection_radio_buttons
-    post = Post.new
-    def post.active; false; end
-    form_for(post) do |f|
-      concat f.collection_radio_buttons(:active, [true, false], :to_s, :to_s)
-    end
-
-    expected = whole_form("/posts", "new_post", "new_post") do
-      "<input id='post_active_true' name='post[active]' type='radio' value='true' />" +
-      "<label for='post_active_true'>true</label>" +
-      "<input checked='checked' id='post_active_false' name='post[active]' type='radio' value='false' />" +
-      "<label for='post_active_false'>false</label>"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_collection_radio_buttons_with_custom_builder_block
-    post = Post.new
-    def post.active; false; end
-
-    form_for(post) do |f|
-      rendered_radio_buttons = f.collection_radio_buttons(:active, [true, false], :to_s, :to_s) do |b|
-        b.label { b.radio_button + b.text }
-      end
-      concat rendered_radio_buttons
-    end
-
-    expected = whole_form("/posts", "new_post", "new_post") do
-      "<label for='post_active_true'>"+
-      "<input id='post_active_true' name='post[active]' type='radio' value='true' />" +
-      "true</label>" +
-      "<label for='post_active_false'>"+
-      "<input checked='checked' id='post_active_false' name='post[active]' type='radio' value='false' />" +
-      "false</label>"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_collection_radio_buttons_with_custom_builder_block_does_not_leak_the_template
-    post = Post.new
-    def post.active; false; end
-    def post.id; 1; end
-
-    form_for(post) do |f|
-      rendered_radio_buttons = f.collection_radio_buttons(:active, [true, false], :to_s, :to_s) do |b|
-        b.label { b.radio_button + b.text }
-      end
-      concat rendered_radio_buttons
-      concat f.hidden_field :id
-    end
-
-    expected = whole_form("/posts", "new_post_1", "new_post") do
-      "<label for='post_active_true'>"+
-      "<input id='post_active_true' name='post[active]' type='radio' value='true' />" +
-      "true</label>" +
-      "<label for='post_active_false'>"+
-      "<input checked='checked' id='post_active_false' name='post[active]' type='radio' value='false' />" +
-      "false</label>"+
-      "<input id='post_id' name='post[id]' type='hidden' value='1' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_collection_check_boxes
-    post = Post.new
-    def post.tag_ids; [1, 3]; end
-    collection = (1..3).map { |i| [i, "Tag #{i}"] }
-    form_for(post) do |f|
-      concat f.collection_check_boxes(:tag_ids, collection, :first, :last)
-    end
-
-    expected = whole_form("/posts", "new_post", "new_post") do
-      "<input checked='checked' id='post_tag_ids_1' name='post[tag_ids][]' type='checkbox' value='1' />" +
-      "<label for='post_tag_ids_1'>Tag 1</label>" +
-      "<input id='post_tag_ids_2' name='post[tag_ids][]' type='checkbox' value='2' />" +
-      "<label for='post_tag_ids_2'>Tag 2</label>" +
-      "<input checked='checked' id='post_tag_ids_3' name='post[tag_ids][]' type='checkbox' value='3' />" +
-      "<label for='post_tag_ids_3'>Tag 3</label>" +
-      "<input name='post[tag_ids][]' type='hidden' value='' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_collection_check_boxes_with_custom_builder_block
-    post = Post.new
-    def post.tag_ids; [1, 3]; end
-    collection = (1..3).map { |i| [i, "Tag #{i}"] }
-    form_for(post) do |f|
-      rendered_check_boxes = f.collection_check_boxes(:tag_ids, collection, :first, :last) do |b|
-        b.label { b.check_box + b.text }
-      end
-      concat rendered_check_boxes
-    end
-
-    expected = whole_form("/posts", "new_post", "new_post") do
-      "<label for='post_tag_ids_1'>" +
-      "<input checked='checked' id='post_tag_ids_1' name='post[tag_ids][]' type='checkbox' value='1' />" +
-      "Tag 1</label>" +
-      "<label for='post_tag_ids_2'>" +
-      "<input id='post_tag_ids_2' name='post[tag_ids][]' type='checkbox' value='2' />" +
-      "Tag 2</label>" +
-      "<label for='post_tag_ids_3'>" +
-      "<input checked='checked' id='post_tag_ids_3' name='post[tag_ids][]' type='checkbox' value='3' />" +
-      "Tag 3</label>" +
-      "<input name='post[tag_ids][]' type='hidden' value='' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_collection_check_boxes_with_custom_builder_block_does_not_leak_the_template
-    post = Post.new
-    def post.tag_ids; [1, 3]; end
-    def post.id; 1; end
-    collection = (1..3).map { |i| [i, "Tag #{i}"] }
-
-    form_for(post) do |f|
-      rendered_check_boxes = f.collection_check_boxes(:tag_ids, collection, :first, :last) do |b|
-        b.label { b.check_box + b.text }
-      end
-      concat rendered_check_boxes
-      concat f.hidden_field :id
-    end
-
-    expected = whole_form("/posts", "new_post_1", "new_post") do
-      "<label for='post_tag_ids_1'>" +
-      "<input checked='checked' id='post_tag_ids_1' name='post[tag_ids][]' type='checkbox' value='1' />" +
-      "Tag 1</label>" +
-      "<label for='post_tag_ids_2'>" +
-      "<input id='post_tag_ids_2' name='post[tag_ids][]' type='checkbox' value='2' />" +
-      "Tag 2</label>" +
-      "<label for='post_tag_ids_3'>" +
-      "<input checked='checked' id='post_tag_ids_3' name='post[tag_ids][]' type='checkbox' value='3' />" +
-      "Tag 3</label>" +
-      "<input name='post[tag_ids][]' type='hidden' value='' />"+
-      "<input id='post_id' name='post[id]' type='hidden' value='1' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_file_field_generate_multipart
-    Post.send :attr_accessor, :file
-
-    form_for(@post, html: { id: 'create-post' }) do |f|
-      concat f.file_field(:file)
-    end
-
-    expected = whole_form("/posts/123", "create-post", "edit_post", method: "patch", multipart: true) do
-      "<input name='post[file]' type='file' id='post_file' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_fields_for_with_file_field_generate_multipart
-    Comment.send :attr_accessor, :file
-
-    form_for(@post) do |f|
-      concat f.fields_for(:comment, @post) { |c|
-        concat c.file_field(:file)
-      }
-    end
-
-    expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch", multipart: true) do
-      "<input name='post[comment][file]' type='file' id='post_comment_file' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_format
-    form_for(@post, format: :json, html: { id: "edit_post_123", class: "edit_post" }) do |f|
-      concat f.label(:title)
-    end
-
-    expected = whole_form("/posts/123.json", "edit_post_123", "edit_post", method: 'patch') do
-      "<label for='post_title'>Title</label>"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_model_using_relative_model_naming
-    blog_post = Blog::Post.new("And his name will be forty and four.", 44)
-
-    form_for(blog_post) do |f|
-      concat f.text_field :title
-      concat f.submit('Edit post')
-    end
-
-    expected = whole_form("/posts/44", "edit_post_44", "edit_post", method: "patch") do
-      "<input name='post[title]' type='text' id='post_title' value='And his name will be forty and four.' />" +
-      "<input name='commit' type='submit' value='Edit post' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_symbol_object_name
-    form_for(@post, as: "other_name", html: { id: "create-post" }) do |f|
-      concat f.label(:title, class: 'post_title')
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
-      concat f.submit('Create post')
-    end
-
-    expected =  whole_form("/posts/123", "create-post", "edit_other_name", method: "patch") do
-      "<label for='other_name_title' class='post_title'>Title</label>" +
-      "<input name='other_name[title]' id='other_name_title' value='Hello World' type='text' />" +
-      "<textarea name='other_name[body]' id='other_name_body'>\nBack to the hill and over it again!</textarea>" +
-      "<input name='other_name[secret]' value='0' type='hidden' />" +
-      "<input name='other_name[secret]' checked='checked' id='other_name_secret' value='1' type='checkbox' />" +
-      "<input name='commit' value='Create post' type='submit' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_method_as_part_of_html_options
-    form_for(@post, url: '/', html: { id: 'create-post', method: :delete }) do |f|
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
-    end
-
-    expected =  whole_form("/", "create-post", "edit_post", method: "delete") do
-      "<input name='post[title]' type='text' id='post_title' value='Hello World' />" +
-      "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" +
-      "<input name='post[secret]' type='hidden' value='0' />" +
-      "<input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_method
-    form_for(@post, url: '/', method: :delete, html: { id: 'create-post' }) do |f|
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
-    end
-
-    expected =  whole_form("/", "create-post", "edit_post", method: "delete") do
-      "<input name='post[title]' type='text' id='post_title' value='Hello World' />" +
-      "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" +
-      "<input name='post[secret]' type='hidden' value='0' />" +
-      "<input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_search_field
-    # Test case for bug which would emit an "object" attribute
-    # when used with form_for using a search_field form helper
-    form_for(Post.new, url: "/search", html: { id: "search-post", method: :get }) do |f|
-      concat f.search_field(:title)
-    end
-
-    expected =  whole_form("/search", "search-post", "new_post", method: "get") do
-      "<input name='post[title]' type='search' id='post_title' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_remote
-    form_for(@post, url: '/', remote: true, html: { id: 'create-post', method: :patch }) do |f|
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
-    end
-
-    expected =  whole_form("/", "create-post", "edit_post", method: "patch", remote: true) do
-      "<input name='post[title]' type='text' id='post_title' value='Hello World' />" +
-      "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" +
-      "<input name='post[secret]' type='hidden' value='0' />" +
-      "<input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_remote_in_html
-    form_for(@post, url: '/', html: { remote: true, id: 'create-post', method: :patch }) do |f|
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
-    end
-
-    expected =  whole_form("/", "create-post", "edit_post", method: "patch", remote: true) do
-      "<input name='post[title]' type='text' id='post_title' value='Hello World' />" +
-      "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" +
-      "<input name='post[secret]' type='hidden' value='0' />" +
-      "<input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_remote_without_html
-    @post.persisted = false
-    @post.stubs(:to_key).returns(nil)
-    form_for(@post, remote: true) do |f|
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
-    end
-
-    expected =  whole_form("/posts", "new_post", "new_post", remote: true) do
-      "<input name='post[title]' type='text' id='post_title' value='Hello World' />" +
-      "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" +
-      "<input name='post[secret]' type='hidden' value='0' />" +
-      "<input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_without_object
-    form_for(:post, html: { id: 'create-post' }) do |f|
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
-    end
-
-    expected = whole_form("/", "create-post") do
-      "<input name='post[title]' type='text' id='post_title' value='Hello World' />" +
-      "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" +
-      "<input name='post[secret]' type='hidden' value='0' />" +
-      "<input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_index
-    form_for(@post, as: "post[]") do |f|
-      concat f.label(:title)
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
-    end
-
-    expected = whole_form('/posts/123', 'edit_post[]', 'edit_post[]', method: 'patch') do
-      "<label for='post_123_title'>Title</label>" +
-      "<input name='post[123][title]' type='text' id='post_123_title' value='Hello World' />" +
-      "<textarea name='post[123][body]' id='post_123_body'>\nBack to the hill and over it again!</textarea>" +
-      "<input name='post[123][secret]' type='hidden' value='0' />" +
-      "<input name='post[123][secret]' checked='checked' type='checkbox' id='post_123_secret' value='1' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_nil_index_option_override
-    form_for(@post, as: "post[]", index: nil) do |f|
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
-    end
-
-    expected = whole_form('/posts/123', 'edit_post[]', 'edit_post[]', method: 'patch') do
-      "<input name='post[][title]' type='text' id='post__title' value='Hello World' />" +
-      "<textarea name='post[][body]' id='post__body'>\nBack to the hill and over it again!</textarea>" +
-      "<input name='post[][secret]' type='hidden' value='0' />" +
-      "<input name='post[][secret]' checked='checked' type='checkbox' id='post__secret' value='1' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_label_error_wrapping
-    form_for(@post) do |f|
-      concat f.label(:author_name, class: 'label')
-      concat f.text_field(:author_name)
-      concat f.submit('Create post')
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      "<div class='field_with_errors'><label for='post_author_name' class='label'>Author name</label></div>" +
-      "<div class='field_with_errors'><input name='post[author_name]' type='text' id='post_author_name' value='' /></div>" +
-      "<input name='commit' type='submit' value='Create post' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_label_error_wrapping_without_conventional_instance_variable
-    post = remove_instance_variable :@post
-
-    form_for(post) do |f|
-      concat f.label(:author_name, class: 'label')
-      concat f.text_field(:author_name)
-      concat f.submit('Create post')
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      "<div class='field_with_errors'><label for='post_author_name' class='label'>Author name</label></div>" +
-      "<div class='field_with_errors'><input name='post[author_name]' type='text' id='post_author_name' value='' /></div>" +
-      "<input name='commit' type='submit' value='Create post' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_label_error_wrapping_block_and_non_block_versions
-    form_for(@post) do |f|
-      concat f.label(:author_name, 'Name', class: 'label')
-      concat f.label(:author_name, class: 'label') { 'Name' }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      "<div class='field_with_errors'><label for='post_author_name' class='label'>Name</label></div>" +
-      "<div class='field_with_errors'><label for='post_author_name' class='label'>Name</label></div>"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_namespace
-    form_for(@post, namespace: 'namespace') do |f|
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
-    end
-
-    expected = whole_form('/posts/123', 'namespace_edit_post_123', 'edit_post', method: 'patch') do
-      "<input name='post[title]' type='text' id='namespace_post_title' value='Hello World' />" +
-      "<textarea name='post[body]' id='namespace_post_body'>\nBack to the hill and over it again!</textarea>" +
-      "<input name='post[secret]' type='hidden' value='0' />" +
-      "<input name='post[secret]' checked='checked' type='checkbox' id='namespace_post_secret' value='1' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_namespace_with_date_select
-    form_for(@post, namespace: 'namespace') do |f|
-      concat f.date_select(:written_on)
-    end
-
-    assert_select 'select#namespace_post_written_on_1i'
-  end
-
-  def test_form_for_with_namespace_with_label
-    form_for(@post, namespace: 'namespace') do |f|
-      concat f.label(:title)
-      concat f.text_field(:title)
-    end
-
-    expected = whole_form('/posts/123', 'namespace_edit_post_123', 'edit_post', method: 'patch') do
-      "<label for='namespace_post_title'>Title</label>" +
-      "<input name='post[title]' type='text' id='namespace_post_title' value='Hello World' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_two_form_for_with_namespace
-    form_for(@post, namespace: 'namespace_1') do |f|
-      concat f.label(:title)
-      concat f.text_field(:title)
-    end
-
-    expected_1 = whole_form('/posts/123', 'namespace_1_edit_post_123', 'edit_post', method: 'patch') do
-      "<label for='namespace_1_post_title'>Title</label>" +
-      "<input name='post[title]' type='text' id='namespace_1_post_title' value='Hello World' />"
-    end
-
-    assert_dom_equal expected_1, output_buffer
-
-    form_for(@post, namespace: 'namespace_2') do |f|
-      concat f.label(:title)
-      concat f.text_field(:title)
-    end
-
-    expected_2 = whole_form('/posts/123', 'namespace_2_edit_post_123', 'edit_post', method: 'patch') do
-      "<label for='namespace_2_post_title'>Title</label>" +
-      "<input name='post[title]' type='text' id='namespace_2_post_title' value='Hello World' />"
-    end
-
-    assert_dom_equal expected_2, output_buffer
-  end
-
-  def test_fields_for_with_namespace
-    @comment.body = 'Hello World'
-    form_for(@post, namespace: 'namespace') do |f|
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.fields_for(@comment) { |c|
-        concat c.text_field(:body)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'namespace_edit_post_123', 'edit_post', method: 'patch') do
-      "<input name='post[title]' type='text' id='namespace_post_title' value='Hello World' />" +
-      "<textarea name='post[body]' id='namespace_post_body'>\nBack to the hill and over it again!</textarea>" +
-      "<input name='post[comment][body]' type='text' id='namespace_post_comment_body' value='Hello World' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_submit_with_object_as_new_record_and_locale_strings
-    old_locale, I18n.locale = I18n.locale, :submit
-
-    @post.persisted = false
-    @post.stubs(:to_key).returns(nil)
-    form_for(@post) do |f|
-      concat f.submit
-    end
-
-    expected = whole_form('/posts', 'new_post', 'new_post') do
-      "<input name='commit' type='submit' value='Create Post' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  ensure
-    I18n.locale = old_locale
-  end
-
-  def test_submit_with_object_as_existing_record_and_locale_strings
-    old_locale, I18n.locale = I18n.locale, :submit
-
-    form_for(@post) do |f|
-      concat f.submit
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      "<input name='commit' type='submit' value='Confirm Post changes' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  ensure
-    I18n.locale = old_locale
-  end
-
-  def test_submit_without_object_and_locale_strings
-    old_locale, I18n.locale = I18n.locale, :submit
-
-    form_for(:post) do |f|
-      concat f.submit class: "extra"
-    end
-
-    expected = whole_form do
-      "<input name='commit' class='extra' type='submit' value='Save changes' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  ensure
-    I18n.locale = old_locale
-  end
-
-  def test_submit_with_object_and_nested_lookup
-    old_locale, I18n.locale = I18n.locale, :submit
-
-    form_for(@post, as: :another_post) do |f|
-      concat f.submit
-    end
-
-    expected = whole_form('/posts/123', 'edit_another_post', 'edit_another_post', method: 'patch') do
-      "<input name='commit' type='submit' value='Update your Post' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  ensure
-    I18n.locale = old_locale
-  end
-
-  def test_nested_fields_for
-    @comment.body = 'Hello World'
-    form_for(@post) do |f|
-      concat f.fields_for(@comment) { |c|
-        concat c.text_field(:body)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      "<input name='post[comment][body]' type='text' id='post_comment_body' value='Hello World' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_nested_collections
-    form_for(@post, as: 'post[]') do |f|
-      concat f.text_field(:title)
-      concat f.fields_for('comment[]', @comment) { |c|
-        concat c.text_field(:name)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post[]', 'edit_post[]', method: 'patch') do
-      "<input name='post[123][title]' type='text' id='post_123_title' value='Hello World' />" +
-      "<input name='post[123][comment][][name]' type='text' id='post_123_comment__name' value='new comment' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_index_and_parent_fields
-    form_for(@post, index: 1) do |c|
-      concat c.text_field(:title)
-      concat c.fields_for('comment', @comment, index: 1) { |r|
-        concat r.text_field(:name)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      "<input name='post[1][title]' type='text' id='post_1_title' value='Hello World' />" +
-      "<input name='post[1][comment][1][name]' type='text' id='post_1_comment_1_name' value='new comment' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_index_and_nested_fields_for
-    output_buffer = form_for(@post, index: 1) do |f|
-      concat f.fields_for(:comment, @post) { |c|
-        concat c.text_field(:title)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      "<input name='post[1][comment][title]' type='text' id='post_1_comment_title' value='Hello World' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_index_on_both
-    form_for(@post, index: 1) do |f|
-      concat f.fields_for(:comment, @post, index: 5) { |c|
-        concat c.text_field(:title)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      "<input name='post[1][comment][5][title]' type='text' id='post_1_comment_5_title' value='Hello World' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_auto_index
-    form_for(@post, as: "post[]") do |f|
-      concat f.fields_for(:comment, @post) { |c|
-        concat c.text_field(:title)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post[]', 'edit_post[]', method: 'patch') do
-      "<input name='post[123][comment][title]' type='text' id='post_123_comment_title' value='Hello World' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_index_radio_button
-    form_for(@post) do |f|
-      concat f.fields_for(:comment, @post, index: 5) { |c|
-        concat c.radio_button(:title, "hello")
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      "<input name='post[comment][5][title]' type='radio' id='post_comment_5_title_hello' value='hello' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_auto_index_on_both
-    form_for(@post, as: "post[]") do |f|
-      concat f.fields_for("comment[]", @post) { |c|
-        concat c.text_field(:title)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post[]', 'edit_post[]', method: 'patch') do
-      "<input name='post[123][comment][123][title]' type='text' id='post_123_comment_123_title' value='Hello World' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_index_and_auto_index
-    output_buffer = form_for(@post, as: "post[]") do |f|
-      concat f.fields_for(:comment, @post, index: 5) { |c|
-        concat c.text_field(:title)
-      }
-    end
-
-    output_buffer << form_for(@post, as: :post, index: 1) do |f|
-      concat f.fields_for("comment[]", @post) { |c|
-        concat c.text_field(:title)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post[]', 'edit_post[]', method: 'patch') do
-      "<input name='post[123][comment][5][title]' type='text' id='post_123_comment_5_title' value='Hello World' />"
-    end + whole_form('/posts/123', 'edit_post', 'edit_post', method: 'patch') do
-      "<input name='post[1][comment][123][title]' type='text' id='post_1_comment_123_title' value='Hello World' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_a_new_record_on_a_nested_attributes_one_to_one_association
-    @post.author = Author.new
-
-    form_for(@post) do |f|
-      concat f.text_field(:title)
-      concat f.fields_for(:author) { |af|
-        concat af.text_field(:name)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input name="post[title]" type="text" id="post_title" value="Hello World" />' +
-        '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="new author" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_explicitly_passed_object_on_a_nested_attributes_one_to_one_association
-    form_for(@post) do |f|
-      f.fields_for(:author, Author.new(123)) do |af|
-        assert_not_nil af.object
-        assert_equal 123, af.object.id
-      end
-    end
-  end
-
-  def test_nested_fields_for_with_an_existing_record_on_a_nested_attributes_one_to_one_association
-    @post.author = Author.new(321)
-
-    form_for(@post) do |f|
-      concat f.text_field(:title)
-      concat f.fields_for(:author) { |af|
-        concat af.text_field(:name)
-      }
-    end
-
-   expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-     '<input name="post[title]" type="text" id="post_title" value="Hello World" />' +
-     '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="author #321" />' +
-     '<input id="post_author_attributes_id" name="post[author_attributes][id]" type="hidden" value="321" />'
-   end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_an_existing_record_on_a_nested_attributes_one_to_one_association_using_erb_and_inline_block
-    @post.author = Author.new(321)
-
-    form_for(@post) do |f|
-      concat f.text_field(:title)
-      concat f.fields_for(:author) { |af|
-        af.text_field(:name)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input name="post[title]" type="text" id="post_title" value="Hello World" />' +
-      '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="author #321" />' +
-      '<input id="post_author_attributes_id" name="post[author_attributes][id]" type="hidden" value="321" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_an_existing_record_on_a_nested_attributes_one_to_one_association_with_disabled_hidden_id
-    @post.author = Author.new(321)
-
-    form_for(@post) do |f|
-      concat f.text_field(:title)
-      concat f.fields_for(:author, include_id: false) { |af|
-        af.text_field(:name)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input name="post[title]" type="text" id="post_title" value="Hello World" />' +
-      '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="author #321" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_an_existing_record_on_a_nested_attributes_one_to_one_association_with_disabled_hidden_id_inherited
-    @post.author = Author.new(321)
-
-    form_for(@post, include_id: false) do |f|
-      concat f.text_field(:title)
-      concat f.fields_for(:author) { |af|
-        af.text_field(:name)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input name="post[title]" type="text" id="post_title" value="Hello World" />' +
-      '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="author #321" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_an_existing_record_on_a_nested_attributes_one_to_one_association_with_disabled_hidden_id_override
-    @post.author = Author.new(321)
-
-    form_for(@post, include_id: false) do |f|
-      concat f.text_field(:title)
-      concat f.fields_for(:author, include_id: true) { |af|
-        af.text_field(:name)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input name="post[title]" type="text" id="post_title" value="Hello World" />' +
-      '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="author #321" />' +
-      '<input id="post_author_attributes_id" name="post[author_attributes][id]" type="hidden" value="321" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_existing_records_on_a_nested_attributes_one_to_one_association_with_explicit_hidden_field_placement
-    @post.author = Author.new(321)
-
-    form_for(@post) do |f|
-      concat f.text_field(:title)
-      concat f.fields_for(:author) { |af|
-        concat af.hidden_field(:id)
-        concat af.text_field(:name)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input name="post[title]" type="text" id="post_title" value="Hello World" />' +
-      '<input id="post_author_attributes_id" name="post[author_attributes][id]" type="hidden" value="321" />' +
-      '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="author #321" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_existing_records_on_a_nested_attributes_collection_association
-    @post.comments = Array.new(2) { |id| Comment.new(id + 1) }
-
-    form_for(@post) do |f|
-      concat f.text_field(:title)
-      @post.comments.each do |comment|
-        concat f.fields_for(:comments, comment) { |cf|
-          concat cf.text_field(:name)
-        }
-      end
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input name="post[title]" type="text" id="post_title" value="Hello World" />' +
-      '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #1" />' +
-      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="1" />' +
-      '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="comment #2" />' +
-      '<input id="post_comments_attributes_1_id" name="post[comments_attributes][1][id]" type="hidden" value="2" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_existing_records_on_a_nested_attributes_collection_association_with_disabled_hidden_id
-    @post.comments = Array.new(2) { |id| Comment.new(id + 1) }
-    @post.author = Author.new(321)
-
-    form_for(@post) do |f|
-      concat f.text_field(:title)
-      concat f.fields_for(:author) { |af|
-        concat af.text_field(:name)
-      }
-      @post.comments.each do |comment|
-        concat f.fields_for(:comments, comment, include_id: false) { |cf|
-          concat cf.text_field(:name)
-        }
-      end
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input name="post[title]" type="text" id="post_title" value="Hello World" />' +
-      '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="author #321" />' +
-      '<input id="post_author_attributes_id" name="post[author_attributes][id]" type="hidden" value="321" />' +
-      '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #1" />' +
-      '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="comment #2" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_existing_records_on_a_nested_attributes_collection_association_with_disabled_hidden_id_inherited
-    @post.comments = Array.new(2) { |id| Comment.new(id + 1) }
-    @post.author = Author.new(321)
-
-    form_for(@post, include_id: false) do |f|
-      concat f.text_field(:title)
-      concat f.fields_for(:author) { |af|
-        concat af.text_field(:name)
-      }
-      @post.comments.each do |comment|
-        concat f.fields_for(:comments, comment) { |cf|
-          concat cf.text_field(:name)
-        }
-      end
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input name="post[title]" type="text" id="post_title" value="Hello World" />' +
-      '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="author #321" />' +
-      '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #1" />' +
-      '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="comment #2" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_existing_records_on_a_nested_attributes_collection_association_with_disabled_hidden_id_override
-    @post.comments = Array.new(2) { |id| Comment.new(id + 1) }
-    @post.author = Author.new(321)
-
-    form_for(@post, include_id: false) do |f|
-      concat f.text_field(:title)
-      concat f.fields_for(:author, include_id: true) { |af|
-        concat af.text_field(:name)
-      }
-      @post.comments.each do |comment|
-        concat f.fields_for(:comments, comment) { |cf|
-          concat cf.text_field(:name)
-        }
-      end
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input name="post[title]" type="text" id="post_title" value="Hello World" />' +
-      '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="author #321" />' +
-      '<input id="post_author_attributes_id" name="post[author_attributes][id]" type="hidden" value="321" />' +
-      '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #1" />' +
-      '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="comment #2" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_existing_records_on_a_nested_attributes_collection_association_using_erb_and_inline_block
-    @post.comments = Array.new(2) { |id| Comment.new(id + 1) }
-
-    form_for(@post) do |f|
-      concat f.text_field(:title)
-      @post.comments.each do |comment|
-        concat f.fields_for(:comments, comment) { |cf|
-          cf.text_field(:name)
-        }
-      end
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input name="post[title]" type="text" id="post_title" value="Hello World" />' +
-      '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #1" />' +
-      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="1" />' +
-      '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="comment #2" />' +
-      '<input id="post_comments_attributes_1_id" name="post[comments_attributes][1][id]" type="hidden" value="2" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_existing_records_on_a_nested_attributes_collection_association_with_explicit_hidden_field_placement
-    @post.comments = Array.new(2) { |id| Comment.new(id + 1) }
-
-    form_for(@post) do |f|
-      concat f.text_field(:title)
-      @post.comments.each do |comment|
-        concat f.fields_for(:comments, comment) { |cf|
-          concat cf.hidden_field(:id)
-          concat cf.text_field(:name)
-        }
-      end
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input name="post[title]" type="text" id="post_title" value="Hello World" />' +
-      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="1" />' +
-      '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #1" />' +
-      '<input id="post_comments_attributes_1_id" name="post[comments_attributes][1][id]" type="hidden" value="2" />' +
-      '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="comment #2" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_new_records_on_a_nested_attributes_collection_association
-    @post.comments = [Comment.new, Comment.new]
-
-    form_for(@post) do |f|
-      concat f.text_field(:title)
-      @post.comments.each do |comment|
-        concat f.fields_for(:comments, comment) { |cf|
-          concat cf.text_field(:name)
-        }
-      end
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input name="post[title]" type="text" id="post_title" value="Hello World" />' +
-      '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="new comment" />' +
-      '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="new comment" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_existing_and_new_records_on_a_nested_attributes_collection_association
-    @post.comments = [Comment.new(321), Comment.new]
-
-    form_for(@post) do |f|
-      concat f.text_field(:title)
-      @post.comments.each do |comment|
-        concat f.fields_for(:comments, comment) { |cf|
-          concat cf.text_field(:name)
-        }
-      end
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input name="post[title]" type="text" id="post_title" value="Hello World" />' +
-      '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #321" />' +
-      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="321" />' +
-      '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="new comment" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_an_empty_supplied_attributes_collection
-    form_for(@post) do |f|
-      concat f.text_field(:title)
-      f.fields_for(:comments, []) do |cf|
-        concat cf.text_field(:name)
-      end
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input name="post[title]" type="text" id="post_title" value="Hello World" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_existing_records_on_a_supplied_nested_attributes_collection
-    @post.comments = Array.new(2) { |id| Comment.new(id + 1) }
-
-    form_for(@post) do |f|
-      concat f.text_field(:title)
-      concat f.fields_for(:comments, @post.comments) { |cf|
-        concat cf.text_field(:name)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input name="post[title]" type="text" id="post_title" value="Hello World" />' +
-      '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #1" />' +
-      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="1" />' +
-      '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="comment #2" />' +
-      '<input id="post_comments_attributes_1_id" name="post[comments_attributes][1][id]" type="hidden" value="2" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_arel_like
-    @post.comments = ArelLike.new
-
-    form_for(@post) do |f|
-      concat f.text_field(:title)
-      concat f.fields_for(:comments, @post.comments) { |cf|
-        concat cf.text_field(:name)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input name="post[title]" type="text" id="post_title" value="Hello World" />' +
-      '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #1" />' +
-      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="1" />' +
-      '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="comment #2" />' +
-      '<input id="post_comments_attributes_1_id" name="post[comments_attributes][1][id]" type="hidden" value="2" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_existing_records_on_a_supplied_nested_attributes_collection_different_from_record_one
-    comments = Array.new(2) { |id| Comment.new(id + 1) }
-    @post.comments = []
-
-    form_for(@post) do |f|
-      concat f.text_field(:title)
-      concat f.fields_for(:comments, comments) { |cf|
-        concat cf.text_field(:name)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input name="post[title]" type="text" id="post_title" value="Hello World" />' +
-      '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #1" />' +
-      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="1" />' +
-      '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="comment #2" />' +
-      '<input id="post_comments_attributes_1_id" name="post[comments_attributes][1][id]" type="hidden" value="2" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_on_a_nested_attributes_collection_association_yields_only_builder
-    @post.comments = [Comment.new(321), Comment.new]
-    yielded_comments = []
-
-    form_for(@post) do |f|
-      concat f.text_field(:title)
-      concat f.fields_for(:comments) { |cf|
-        concat cf.text_field(:name)
-        yielded_comments << cf.object
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input name="post[title]" type="text" id="post_title" value="Hello World" />' +
-      '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #321" />' +
-      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="321" />' +
-      '<input id="post_comments_attributes_1_name" name="post[comments_attributes][1][name]" type="text" value="new comment" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-    assert_equal yielded_comments, @post.comments
-  end
-
-  def test_nested_fields_for_with_child_index_option_override_on_a_nested_attributes_collection_association
-    @post.comments = []
-
-    form_for(@post) do |f|
-      concat f.fields_for(:comments, Comment.new(321), child_index: 'abc') { |cf|
-        concat cf.text_field(:name)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input id="post_comments_attributes_abc_name" name="post[comments_attributes][abc][name]" type="text" value="comment #321" />' +
-      '<input id="post_comments_attributes_abc_id" name="post[comments_attributes][abc][id]" type="hidden" value="321" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  class FakeAssociationProxy
-    def to_ary
-      [1, 2, 3]
-    end
-  end
-
-  def test_nested_fields_for_with_child_index_option_override_on_a_nested_attributes_collection_association_with_proxy
-    @post.comments = FakeAssociationProxy.new
-
-    form_for(@post) do |f|
-      concat f.fields_for(:comments, Comment.new(321), child_index: 'abc') { |cf|
-        concat cf.text_field(:name)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input id="post_comments_attributes_abc_name" name="post[comments_attributes][abc][name]" type="text" value="comment #321" />' +
-      '<input id="post_comments_attributes_abc_id" name="post[comments_attributes][abc][id]" type="hidden" value="321" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_index_method_with_existing_records_on_a_nested_attributes_collection_association
-    @post.comments = Array.new(2) { |id| Comment.new(id + 1) }
-
-    form_for(@post) do |f|
-      expected = 0
-      @post.comments.each do |comment|
-        f.fields_for(:comments, comment) { |cf|
-          assert_equal cf.index, expected
-          expected += 1
-        }
-      end
-    end
-  end
-
-  def test_nested_fields_for_index_method_with_existing_and_new_records_on_a_nested_attributes_collection_association
-    @post.comments = [Comment.new(321), Comment.new]
-
-    form_for(@post) do |f|
-      expected = 0
-      @post.comments.each do |comment|
-        f.fields_for(:comments, comment) { |cf|
-          assert_equal cf.index, expected
-          expected += 1
-        }
-      end
-    end
-  end
-
-  def test_nested_fields_for_index_method_with_existing_records_on_a_supplied_nested_attributes_collection
-    @post.comments = Array.new(2) { |id| Comment.new(id + 1) }
-
-    form_for(@post) do |f|
-      expected = 0
-      f.fields_for(:comments, @post.comments) { |cf|
-        assert_equal cf.index, expected
-        expected += 1
-      }
-    end
-  end
-
-  def test_nested_fields_for_index_method_with_child_index_option_override_on_a_nested_attributes_collection_association
-    @post.comments = []
-
-    form_for(@post) do |f|
-      f.fields_for(:comments, Comment.new(321), child_index: 'abc') { |cf|
-        assert_equal cf.index, 'abc'
-      }
-    end
-  end
-
-  def test_nested_fields_uses_unique_indices_for_different_collection_associations
-    @post.comments = [Comment.new(321)]
-    @post.tags = [Tag.new(123), Tag.new(456)]
-    @post.comments[0].relevances = []
-    @post.tags[0].relevances = []
-    @post.tags[1].relevances = []
-
-    form_for(@post) do |f|
-      concat f.fields_for(:comments, @post.comments[0]) { |cf|
-        concat cf.text_field(:name)
-        concat cf.fields_for(:relevances, CommentRelevance.new(314)) { |crf|
-          concat crf.text_field(:value)
-        }
-      }
-      concat f.fields_for(:tags, @post.tags[0]) { |tf|
-        concat tf.text_field(:value)
-        concat tf.fields_for(:relevances, TagRelevance.new(3141)) { |trf|
-          concat trf.text_field(:value)
-        }
-      }
-      concat f.fields_for('tags', @post.tags[1]) { |tf|
-        concat tf.text_field(:value)
-        concat tf.fields_for(:relevances, TagRelevance.new(31415)) { |trf|
-          concat trf.text_field(:value)
-        }
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input id="post_comments_attributes_0_name" name="post[comments_attributes][0][name]" type="text" value="comment #321" />' +
-      '<input id="post_comments_attributes_0_relevances_attributes_0_value" name="post[comments_attributes][0][relevances_attributes][0][value]" type="text" value="commentrelevance #314" />' +
-      '<input id="post_comments_attributes_0_relevances_attributes_0_id" name="post[comments_attributes][0][relevances_attributes][0][id]" type="hidden" value="314" />' +
-      '<input id="post_comments_attributes_0_id" name="post[comments_attributes][0][id]" type="hidden" value="321" />' +
-      '<input id="post_tags_attributes_0_value" name="post[tags_attributes][0][value]" type="text" value="tag #123" />' +
-      '<input id="post_tags_attributes_0_relevances_attributes_0_value" name="post[tags_attributes][0][relevances_attributes][0][value]" type="text" value="tagrelevance #3141" />' +
-      '<input id="post_tags_attributes_0_relevances_attributes_0_id" name="post[tags_attributes][0][relevances_attributes][0][id]" type="hidden" value="3141" />' +
-      '<input id="post_tags_attributes_0_id" name="post[tags_attributes][0][id]" type="hidden" value="123" />' +
-      '<input id="post_tags_attributes_1_value" name="post[tags_attributes][1][value]" type="text" value="tag #456" />' +
-      '<input id="post_tags_attributes_1_relevances_attributes_0_value" name="post[tags_attributes][1][relevances_attributes][0][value]" type="text" value="tagrelevance #31415" />' +
-      '<input id="post_tags_attributes_1_relevances_attributes_0_id" name="post[tags_attributes][1][relevances_attributes][0][id]" type="hidden" value="31415" />' +
-      '<input id="post_tags_attributes_1_id" name="post[tags_attributes][1][id]" type="hidden" value="456" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_with_hash_like_model
-    @author = HashBackedAuthor.new
-
-    form_for(@post) do |f|
-      concat f.fields_for(:author, @author) { |af|
-        concat af.text_field(:name)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      '<input id="post_author_attributes_name" name="post[author_attributes][name]" type="text" value="hash backed author" />'
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_fields_for
-    output_buffer = fields_for(:post, @post) do |f|
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
-    end
-
-    expected =
-      "<input name='post[title]' type='text' id='post_title' value='Hello World' />" +
-      "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" +
-      "<input name='post[secret]' type='hidden' value='0' />" +
-      "<input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' />"
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_fields_for_with_index
-    output_buffer = fields_for("post[]", @post) do |f|
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
-    end
-
-    expected =
-      "<input name='post[123][title]' type='text' id='post_123_title' value='Hello World' />" +
-      "<textarea name='post[123][body]' id='post_123_body'>\nBack to the hill and over it again!</textarea>" +
-      "<input name='post[123][secret]' type='hidden' value='0' />" +
-      "<input name='post[123][secret]' checked='checked' type='checkbox' id='post_123_secret' value='1' />"
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_fields_for_with_nil_index_option_override
-    output_buffer = fields_for("post[]", @post, index: nil) do |f|
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
-    end
-
-    expected =
-      "<input name='post[][title]' type='text' id='post__title' value='Hello World' />" +
-      "<textarea name='post[][body]' id='post__body'>\nBack to the hill and over it again!</textarea>" +
-      "<input name='post[][secret]' type='hidden' value='0' />" +
-      "<input name='post[][secret]' checked='checked' type='checkbox' id='post__secret' value='1' />"
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_fields_for_with_index_option_override
-    output_buffer = fields_for("post[]", @post, index: "abc") do |f|
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
-    end
-
-    expected =
-      "<input name='post[abc][title]' type='text' id='post_abc_title' value='Hello World' />" +
-      "<textarea name='post[abc][body]' id='post_abc_body'>\nBack to the hill and over it again!</textarea>" +
-      "<input name='post[abc][secret]' type='hidden' value='0' />" +
-      "<input name='post[abc][secret]' checked='checked' type='checkbox' id='post_abc_secret' value='1' />"
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_fields_for_without_object
-    output_buffer = fields_for(:post) do |f|
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
-    end
-
-    expected =
-      "<input name='post[title]' type='text' id='post_title' value='Hello World' />" +
-      "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" +
-      "<input name='post[secret]' type='hidden' value='0' />" +
-      "<input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' />"
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_fields_for_with_only_object
-    output_buffer = fields_for(@post) do |f|
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
-    end
-
-    expected =
-      "<input name='post[title]' type='text' id='post_title' value='Hello World' />" +
-      "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" +
-      "<input name='post[secret]' type='hidden' value='0' />" +
-      "<input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' />"
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_fields_for_object_with_bracketed_name
-    output_buffer = fields_for("author[post]", @post) do |f|
-      concat f.label(:title)
-      concat f.text_field(:title)
-    end
-
-    assert_dom_equal "<label for=\"author_post_title\">Title</label>" +
-    "<input name='author[post][title]' type='text' id='author_post_title' value='Hello World' />",
-      output_buffer
-  end
-
-  def test_fields_for_object_with_bracketed_name_and_index
-    output_buffer = fields_for("author[post]", @post, index: 1) do |f|
-      concat f.label(:title)
-      concat f.text_field(:title)
-    end
-
-    assert_dom_equal "<label for=\"author_post_1_title\">Title</label>" +
-      "<input name='author[post][1][title]' type='text' id='author_post_1_title' value='Hello World' />",
-      output_buffer
-  end
-
-  def test_form_builder_does_not_have_form_for_method
-    assert !ActionView::Helpers::FormBuilder.instance_methods.include?(:form_for)
-  end
-
-  def test_form_for_and_fields_for
-    form_for(@post, as: :post, html: { id: 'create-post' }) do |post_form|
-      concat post_form.text_field(:title)
-      concat post_form.text_area(:body)
-
-      concat fields_for(:parent_post, @post) { |parent_fields|
-        concat parent_fields.check_box(:secret)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'create-post', 'edit_post', method: 'patch') do
-      "<input name='post[title]' type='text' id='post_title' value='Hello World' />" +
-      "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" +
-      "<input name='parent_post[secret]' type='hidden' value='0' />" +
-      "<input name='parent_post[secret]' checked='checked' type='checkbox' id='parent_post_secret' value='1' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_and_fields_for_with_object
-    form_for(@post, as: :post, html: { id: 'create-post' }) do |post_form|
-      concat post_form.text_field(:title)
-      concat post_form.text_area(:body)
-
-      concat post_form.fields_for(@comment) { |comment_fields|
-        concat comment_fields.text_field(:name)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'create-post', 'edit_post', method: 'patch') do
-      "<input name='post[title]' type='text' id='post_title' value='Hello World' />" +
-      "<textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea>" +
-      "<input name='post[comment][name]' type='text' id='post_comment_name' value='new comment' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_and_fields_for_with_non_nested_association_and_without_object
-    form_for(@post) do |f|
-      concat f.fields_for(:category) { |c|
-        concat c.text_field(:name)
-      }
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      "<input name='post[category][name]' type='text' id='post_category_name' />"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  class LabelledFormBuilder < ActionView::Helpers::FormBuilder
-    (field_helpers - %w(hidden_field)).each do |selector|
-      class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-        def #{selector}(field, *args, &proc)
-          ("<label for='\#{field}'>\#{field.to_s.humanize}:</label> " + super + "<br/>").html_safe
-        end
-      RUBY_EVAL
-    end
-  end
-
-  def test_form_for_with_labelled_builder
-    form_for(@post, builder: LabelledFormBuilder) do |f|
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      "<label for='title'>Title:</label> <input name='post[title]' type='text' id='post_title' value='Hello World' /><br/>" +
-      "<label for='body'>Body:</label> <textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea><br/>" +
-      "<label for='secret'>Secret:</label> <input name='post[secret]' type='hidden' value='0' /><input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' /><br/>"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_default_form_builder
-    old_default_form_builder, ActionView::Base.default_form_builder =
-      ActionView::Base.default_form_builder, LabelledFormBuilder
-
-    form_for(@post) do |f|
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      "<label for='title'>Title:</label> <input name='post[title]' type='text' id='post_title' value='Hello World' /><br/>" +
-      "<label for='body'>Body:</label> <textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea><br/>" +
-      "<label for='secret'>Secret:</label> <input name='post[secret]' type='hidden' value='0' /><input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' /><br/>"
-    end
-
-    assert_dom_equal expected, output_buffer
-  ensure
-    ActionView::Base.default_form_builder = old_default_form_builder
-  end
-
-  def test_lazy_loading_default_form_builder
-    old_default_form_builder, ActionView::Base.default_form_builder =
-      ActionView::Base.default_form_builder, "FormHelperTest::LabelledFormBuilder"
-
-    form_for(@post) do |f|
-      concat f.text_field(:title)
-    end
-
-    expected = whole_form('/posts/123', 'edit_post_123', 'edit_post', method: 'patch') do
-      "<label for='title'>Title:</label> <input name='post[title]' type='text' id='post_title' value='Hello World' /><br/>"
-    end
-
-    assert_dom_equal expected, output_buffer
-  ensure
-    ActionView::Base.default_form_builder = old_default_form_builder
-  end
-
-  def test_fields_for_with_labelled_builder
-    output_buffer = fields_for(:post, @post, builder: LabelledFormBuilder) do |f|
-      concat f.text_field(:title)
-      concat f.text_area(:body)
-      concat f.check_box(:secret)
-    end
-
-    expected =
-      "<label for='title'>Title:</label> <input name='post[title]' type='text' id='post_title' value='Hello World' /><br/>" +
-      "<label for='body'>Body:</label> <textarea name='post[body]' id='post_body'>\nBack to the hill and over it again!</textarea><br/>" +
-      "<label for='secret'>Secret:</label> <input name='post[secret]' type='hidden' value='0' /><input name='post[secret]' checked='checked' type='checkbox' id='post_secret' value='1' /><br/>"
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_labelled_builder_with_nested_fields_for_without_options_hash
-    klass = nil
-
-    form_for(@post, builder: LabelledFormBuilder) do |f|
-      f.fields_for(:comments, Comment.new) do |nested_fields|
-        klass = nested_fields.class
-        ''
-      end
-    end
-
-    assert_equal LabelledFormBuilder, klass
-  end
-
-  def test_form_for_with_labelled_builder_with_nested_fields_for_with_options_hash
-    klass = nil
-
-    form_for(@post, builder: LabelledFormBuilder) do |f|
-      f.fields_for(:comments, Comment.new, index: 'foo') do |nested_fields|
-        klass = nested_fields.class
-        ''
-      end
-    end
-
-    assert_equal LabelledFormBuilder, klass
-  end
-
-  def test_form_for_with_labelled_builder_path
-    path = nil
-
-    form_for(@post, builder: LabelledFormBuilder) do |f|
-      path = f.to_partial_path
-      ''
-    end
-
-    assert_equal 'labelled_form', path
-  end
-
-  class LabelledFormBuilderSubclass < LabelledFormBuilder; end
-
-  def test_form_for_with_labelled_builder_with_nested_fields_for_with_custom_builder
-    klass = nil
-
-    form_for(@post, builder: LabelledFormBuilder) do |f|
-      f.fields_for(:comments, Comment.new, builder: LabelledFormBuilderSubclass) do |nested_fields|
-        klass = nested_fields.class
-        ''
-      end
-    end
-
-    assert_equal LabelledFormBuilderSubclass, klass
-  end
-
-  def test_form_for_with_html_options_adds_options_to_form_tag
-    form_for(@post, html: { id: 'some_form', class: 'some_class', multipart: true }) do |f| end
-    expected = whole_form("/posts/123", "some_form", "some_class", method: "patch", multipart: "multipart/form-data")
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_string_url_option
-    form_for(@post, url: 'http://www.otherdomain.com') do |f| end
-
-    assert_equal whole_form("http://www.otherdomain.com", "edit_post_123", "edit_post", method: "patch"), output_buffer
-  end
-
-  def test_form_for_with_hash_url_option
-    form_for(@post, url: { controller: 'controller', action: 'action' }) do |f| end
-
-    assert_equal 'controller', @url_for_options[:controller]
-    assert_equal 'action', @url_for_options[:action]
-  end
-
-  def test_form_for_with_record_url_option
-    form_for(@post, url: @post) do |f| end
-
-    expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch")
-    assert_equal expected, output_buffer
-  end
-
-  def test_form_for_with_existing_object
-    form_for(@post) do |f| end
-
-    expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch")
-    assert_equal expected, output_buffer
-  end
-
-  def test_form_for_with_new_object
-    post = Post.new
-    post.persisted = false
-    def post.to_key; nil; end
-
-    form_for(post) do |f| end
-
-    expected = whole_form("/posts", "new_post", "new_post")
-    assert_equal expected, output_buffer
-  end
-
-  def test_form_for_with_existing_object_in_list
-    @comment.save
-    form_for([@post, @comment]) {}
-
-    expected = whole_form(post_comment_path(@post, @comment), "edit_comment_1", "edit_comment", method: "patch")
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_new_object_in_list
-    form_for([@post, @comment]) {}
-
-    expected = whole_form(post_comments_path(@post), "new_comment", "new_comment")
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_existing_object_and_namespace_in_list
-    @comment.save
-    form_for([:admin, @post, @comment]) {}
-
-    expected = whole_form(admin_post_comment_path(@post, @comment), "edit_comment_1", "edit_comment", method: "patch")
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_new_object_and_namespace_in_list
-    form_for([:admin, @post, @comment]) {}
-
-    expected = whole_form(admin_post_comments_path(@post), "new_comment", "new_comment")
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_existing_object_and_custom_url
-    form_for(@post, url: "/super_posts") do |f| end
-
-    expected = whole_form("/super_posts", "edit_post_123", "edit_post", method: "patch")
-    assert_equal expected, output_buffer
-  end
-
-  def test_form_for_with_default_method_as_patch
-    form_for(@post) {}
-    expected = whole_form("/posts/123", "edit_post_123", "edit_post", method: "patch")
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_for_with_data_attributes
-    form_for(@post, data: { behavior: "stuff" }, remote: true) {}
-    assert_match %r|data-behavior="stuff"|, output_buffer
-    assert_match %r|data-remote="true"|, output_buffer
-  end
-
-  def test_fields_for_returns_block_result
-    output = fields_for(Post.new) { |f| "fields" }
-    assert_equal "fields", output
-  end
-
-  def test_form_builder_block_argument_deprecation
-    builder_class = Class.new(ActionView::Helpers::FormBuilder) do
-      def initialize(object_name, object, template, options, block)
-        super
-      end
-    end
-
-    assert_deprecated(/Giving a block to FormBuilder is deprecated and has no effect anymore/) do
-      builder_class.new(:foo, nil, nil, {}, proc {})
-    end
-  end
-
-  def test_form_for_only_instantiates_builder_once
-    initialization_count = 0
-    builder_class = Class.new(ActionView::Helpers::FormBuilder) do
-      define_method :initialize do |*args|
-        super(*args)
-        initialization_count += 1
-      end
-    end
-
-    form_for(@post, builder: builder_class) { }
-    assert_equal 1, initialization_count, 'form builder instantiated more than once'
-  end
-
-  protected
-
-  def hidden_fields(method = nil)
-    txt =  %{<div style="margin:0;padding:0;display:inline">}
-    txt << %{<input name="utf8" type="hidden" value="&#x2713;" />}
-    if method && !%w(get post).include?(method.to_s)
-      txt << %{<input name="_method" type="hidden" value="#{method}" />}
-    end
-    txt << %{</div>}
-  end
-
-  def form_text(action = "/", id = nil, html_class = nil, remote = nil, multipart = nil, method = nil)
-    txt =  %{<form accept-charset="UTF-8" action="#{action}"}
-    txt << %{ enctype="multipart/form-data"} if multipart
-    txt << %{ data-remote="true"} if remote
-    txt << %{ class="#{html_class}"} if html_class
-    txt << %{ id="#{id}"} if id
-    method = method.to_s == "get" ? "get" : "post"
-    txt << %{ method="#{method}">}
-  end
-
-  def whole_form(action = "/", id = nil, html_class = nil, options = {})
-    contents = block_given? ? yield : ""
-
-    method, remote, multipart = options.values_at(:method, :remote, :multipart)
-
-    form_text(action, id, html_class, remote, multipart, method) + hidden_fields(method) + contents + "</form>"
-  end
-
-  def protect_against_forgery?
-    false
-  end
-end
diff --git a/actionpack/test/template/form_options_helper_i18n_test.rb b/actionpack/test/template/form_options_helper_i18n_test.rb
deleted file mode 100644
index 4972ea6511..0000000000
--- a/actionpack/test/template/form_options_helper_i18n_test.rb
+++ /dev/null
@@ -1,27 +0,0 @@
-require 'abstract_unit'
-
-class FormOptionsHelperI18nTests < ActionView::TestCase
-  tests ActionView::Helpers::FormOptionsHelper
-
-  def setup
-    @prompt_message = 'Select!'
-    I18n.backend.send(:init_translations)
-    I18n.backend.store_translations :en, :helpers => { :select => { :prompt => @prompt_message } }
-  end
-
-  def teardown
-    I18n.backend = I18n::Backend::Simple.new
-  end
-
-  def test_select_with_prompt_true_translates_prompt_message
-    I18n.expects(:translate).with('helpers.select.prompt', { :default => 'Please select' })
-    select('post', 'category', [], :prompt => true)
-  end
-
-  def test_select_with_translated_prompt
-    assert_dom_equal(
-      %Q(<select id="post_category" name="post[category]"><option value="">#{@prompt_message}</option>\n</select>),
-      select('post', 'category', [], :prompt => true)
-    )
-  end
-end
diff --git a/actionpack/test/template/form_options_helper_test.rb b/actionpack/test/template/form_options_helper_test.rb
deleted file mode 100644
index 1715902927..0000000000
--- a/actionpack/test/template/form_options_helper_test.rb
+++ /dev/null
@@ -1,1304 +0,0 @@
-require 'abstract_unit'
-require 'tzinfo'
-
-class Map < Hash
-  def category
-    "<mus>"
-  end
-end
-
-TZInfo::Timezone.cattr_reader :loaded_zones
-
-class FormOptionsHelperTest < ActionView::TestCase
-  tests ActionView::Helpers::FormOptionsHelper
-
-  silence_warnings do
-    Post        = Struct.new('Post', :title, :author_name, :body, :secret, :written_on, :category, :origin, :allow_comments)
-    Continent   = Struct.new('Continent', :continent_name, :countries)
-    Country     = Struct.new('Country', :country_id, :country_name)
-    Firm        = Struct.new('Firm', :time_zone)
-    Album       = Struct.new('Album', :id, :title, :genre)
-  end
-
-  def setup
-    @fake_timezones = %w(A B C D E).map do |id|
-      tz = TZInfo::Timezone.loaded_zones[id] = stub(:name => id, :to_s => id)
-      ActiveSupport::TimeZone.stubs(:[]).with(id).returns(tz)
-      tz
-    end
-    ActiveSupport::TimeZone.stubs(:all).returns(@fake_timezones)
-  end
-
-  def test_collection_options
-    assert_dom_equal(
-      "<option value=\"&lt;Abe&gt;\">&lt;Abe&gt; went home</option>\n<option value=\"Babe\">Babe went home</option>\n<option value=\"Cabe\">Cabe went home</option>",
-      options_from_collection_for_select(dummy_posts, "author_name", "title")
-    )
-  end
-
-
-  def test_collection_options_with_preselected_value
-    assert_dom_equal(
-      "<option value=\"&lt;Abe&gt;\">&lt;Abe&gt; went home</option>\n<option value=\"Babe\" selected=\"selected\">Babe went home</option>\n<option value=\"Cabe\">Cabe went home</option>",
-      options_from_collection_for_select(dummy_posts, "author_name", "title", "Babe")
-    )
-  end
-
-  def test_collection_options_with_preselected_value_array
-      assert_dom_equal(
-        "<option value=\"&lt;Abe&gt;\">&lt;Abe&gt; went home</option>\n<option value=\"Babe\" selected=\"selected\">Babe went home</option>\n<option value=\"Cabe\" selected=\"selected\">Cabe went home</option>",
-        options_from_collection_for_select(dummy_posts, "author_name", "title", [ "Babe", "Cabe" ])
-      )
-  end
-
-  def test_collection_options_with_proc_for_selected
-    assert_dom_equal(
-      "<option value=\"&lt;Abe&gt;\">&lt;Abe&gt; went home</option>\n<option value=\"Babe\" selected=\"selected\">Babe went home</option>\n<option value=\"Cabe\">Cabe went home</option>",
-      options_from_collection_for_select(dummy_posts, "author_name", "title", lambda{|p| p.author_name == 'Babe' })
-    )
-  end
-
-  def test_collection_options_with_disabled_value
-    assert_dom_equal(
-      "<option value=\"&lt;Abe&gt;\">&lt;Abe&gt; went home</option>\n<option value=\"Babe\" disabled=\"disabled\">Babe went home</option>\n<option value=\"Cabe\">Cabe went home</option>",
-      options_from_collection_for_select(dummy_posts, "author_name", "title", :disabled => "Babe")
-    )
-  end
-
-  def test_collection_options_with_disabled_array
-    assert_dom_equal(
-      "<option value=\"&lt;Abe&gt;\">&lt;Abe&gt; went home</option>\n<option value=\"Babe\" disabled=\"disabled\">Babe went home</option>\n<option value=\"Cabe\" disabled=\"disabled\">Cabe went home</option>",
-      options_from_collection_for_select(dummy_posts, "author_name", "title", :disabled => [ "Babe", "Cabe" ])
-    )
-  end
-
-  def test_collection_options_with_preselected_and_disabled_value
-    assert_dom_equal(
-      "<option value=\"&lt;Abe&gt;\">&lt;Abe&gt; went home</option>\n<option value=\"Babe\" disabled=\"disabled\">Babe went home</option>\n<option value=\"Cabe\" selected=\"selected\">Cabe went home</option>",
-      options_from_collection_for_select(dummy_posts, "author_name", "title", :selected => "Cabe", :disabled => "Babe")
-    )
-  end
-
-  def test_collection_options_with_proc_for_disabled
-    assert_dom_equal(
-      "<option value=\"&lt;Abe&gt;\">&lt;Abe&gt; went home</option>\n<option value=\"Babe\" disabled=\"disabled\">Babe went home</option>\n<option value=\"Cabe\" disabled=\"disabled\">Cabe went home</option>",
-      options_from_collection_for_select(dummy_posts, "author_name", "title", :disabled => lambda {|p| %w(Babe Cabe).include?(p.author_name)})
-    )
-  end
-
-  def test_collection_options_with_proc_for_value_method
-    assert_dom_equal(
-      "<option value=\"&lt;Abe&gt;\">&lt;Abe&gt; went home</option>\n<option value=\"Babe\">Babe went home</option>\n<option value=\"Cabe\">Cabe went home</option>",
-      options_from_collection_for_select(dummy_posts, lambda { |p| p.author_name }, "title")
-    )
-  end
-
-  def test_collection_options_with_proc_for_text_method
-    assert_dom_equal(
-      "<option value=\"&lt;Abe&gt;\">&lt;Abe&gt; went home</option>\n<option value=\"Babe\">Babe went home</option>\n<option value=\"Cabe\">Cabe went home</option>",
-      options_from_collection_for_select(dummy_posts, "author_name", lambda { |p| p.title })
-    )
-  end
-
-  def test_collection_options_with_element_attributes
-    assert_dom_equal(
-      "<option value=\"USA\" class=\"bold\">USA</option>",
-      options_from_collection_for_select([[ "USA", "USA", { :class => 'bold' } ]], :first, :second)
-    )
-  end
-
-  def test_string_options_for_select
-    options = "<option value=\"Denmark\">Denmark</option><option value=\"USA\">USA</option><option value=\"Sweden\">Sweden</option>"
-    assert_dom_equal(
-      options,
-      options_for_select(options)
-    )
-  end
-
-  def test_array_options_for_select
-    assert_dom_equal(
-      "<option value=\"&lt;Denmark&gt;\">&lt;Denmark&gt;</option>\n<option value=\"USA\">USA</option>\n<option value=\"Sweden\">Sweden</option>",
-      options_for_select([ "<Denmark>", "USA", "Sweden" ])
-    )
-  end
-
-  def test_array_options_for_select_with_selection
-    assert_dom_equal(
-      "<option value=\"Denmark\">Denmark</option>\n<option value=\"&lt;USA&gt;\" selected=\"selected\">&lt;USA&gt;</option>\n<option value=\"Sweden\">Sweden</option>",
-      options_for_select([ "Denmark", "<USA>", "Sweden" ], "<USA>")
-    )
-  end
-
-  def test_array_options_for_select_with_selection_array
-      assert_dom_equal(
-        "<option value=\"Denmark\">Denmark</option>\n<option value=\"&lt;USA&gt;\" selected=\"selected\">&lt;USA&gt;</option>\n<option value=\"Sweden\" selected=\"selected\">Sweden</option>",
-        options_for_select([ "Denmark", "<USA>", "Sweden" ], [ "<USA>", "Sweden" ])
-      )
-  end
-
-  def test_array_options_for_select_with_disabled_value
-    assert_dom_equal(
-      "<option value=\"Denmark\">Denmark</option>\n<option value=\"&lt;USA&gt;\" disabled=\"disabled\">&lt;USA&gt;</option>\n<option value=\"Sweden\">Sweden</option>",
-      options_for_select([ "Denmark", "<USA>", "Sweden" ], :disabled => "<USA>")
-    )
-  end
-
-  def test_array_options_for_select_with_disabled_array
-    assert_dom_equal(
-      "<option value=\"Denmark\">Denmark</option>\n<option value=\"&lt;USA&gt;\" disabled=\"disabled\">&lt;USA&gt;</option>\n<option value=\"Sweden\" disabled=\"disabled\">Sweden</option>",
-      options_for_select([ "Denmark", "<USA>", "Sweden" ], :disabled => ["<USA>", "Sweden"])
-    )
-  end
-
-  def test_array_options_for_select_with_selection_and_disabled_value
-    assert_dom_equal(
-      "<option value=\"Denmark\" selected=\"selected\">Denmark</option>\n<option value=\"&lt;USA&gt;\" disabled=\"disabled\">&lt;USA&gt;</option>\n<option value=\"Sweden\">Sweden</option>",
-      options_for_select([ "Denmark", "<USA>", "Sweden" ], :selected => "Denmark", :disabled => "<USA>")
-    )
-  end
-
-  def test_boolean_array_options_for_select_with_selection_and_disabled_value
-    assert_dom_equal(
-      "<option value=\"true\">true</option>\n<option value=\"false\" selected=\"selected\">false</option>",
-      options_for_select([ true, false ], :selected => false, :disabled => nil)
-    )
-  end
-
-  def test_range_options_for_select
-    assert_dom_equal(
-      "<option value=\"1\">1</option>\n<option value=\"2\">2</option>\n<option value=\"3\">3</option>",
-      options_for_select(1..3)
-    )
-  end
-
-  def test_array_options_for_string_include_in_other_string_bug_fix
-      assert_dom_equal(
-        "<option value=\"ruby\">ruby</option>\n<option value=\"rubyonrails\" selected=\"selected\">rubyonrails</option>",
-        options_for_select([ "ruby", "rubyonrails" ], "rubyonrails")
-      )
-      assert_dom_equal(
-        "<option value=\"ruby\" selected=\"selected\">ruby</option>\n<option value=\"rubyonrails\">rubyonrails</option>",
-        options_for_select([ "ruby", "rubyonrails" ], "ruby")
-      )
-      assert_dom_equal(
-        %(<option value="ruby" selected="selected">ruby</option>\n<option value="rubyonrails">rubyonrails</option>\n<option value=""></option>),
-        options_for_select([ "ruby", "rubyonrails", nil ], "ruby")
-      )
-  end
-
-  def test_hash_options_for_select
-    assert_dom_equal(
-      "<option value=\"Dollar\">$</option>\n<option value=\"&lt;Kroner&gt;\">&lt;DKR&gt;</option>",
-      options_for_select("$" => "Dollar", "<DKR>" => "<Kroner>").split("\n").join("\n")
-    )
-    assert_dom_equal(
-      "<option value=\"Dollar\" selected=\"selected\">$</option>\n<option value=\"&lt;Kroner&gt;\">&lt;DKR&gt;</option>",
-      options_for_select({ "$" => "Dollar", "<DKR>" => "<Kroner>" }, "Dollar").split("\n").join("\n")
-    )
-    assert_dom_equal(
-      "<option value=\"Dollar\" selected=\"selected\">$</option>\n<option value=\"&lt;Kroner&gt;\" selected=\"selected\">&lt;DKR&gt;</option>",
-      options_for_select({ "$" => "Dollar", "<DKR>" => "<Kroner>" }, [ "Dollar", "<Kroner>" ]).split("\n").join("\n")
-    )
-  end
-
-  def test_ducktyped_options_for_select
-    quack = Struct.new(:first, :last)
-    assert_dom_equal(
-      "<option value=\"&lt;Kroner&gt;\">&lt;DKR&gt;</option>\n<option value=\"Dollar\">$</option>",
-      options_for_select([quack.new("<DKR>", "<Kroner>"), quack.new("$", "Dollar")])
-    )
-    assert_dom_equal(
-      "<option value=\"&lt;Kroner&gt;\">&lt;DKR&gt;</option>\n<option value=\"Dollar\" selected=\"selected\">$</option>",
-      options_for_select([quack.new("<DKR>", "<Kroner>"), quack.new("$", "Dollar")], "Dollar")
-    )
-    assert_dom_equal(
-      "<option value=\"&lt;Kroner&gt;\" selected=\"selected\">&lt;DKR&gt;</option>\n<option value=\"Dollar\" selected=\"selected\">$</option>",
-      options_for_select([quack.new("<DKR>", "<Kroner>"), quack.new("$", "Dollar")], ["Dollar", "<Kroner>"])
-    )
-  end
-
-  def test_collection_options_with_preselected_value_as_string_and_option_value_is_integer
-    albums = [ Album.new(1, "first","rap"), Album.new(2, "second","pop")]
-    assert_dom_equal(
-    %(<option selected="selected" value="1">rap</option>\n<option value="2">pop</option>),
-    options_from_collection_for_select(albums, "id", "genre", :selected => "1")
-    )
-  end
-
-  def test_collection_options_with_preselected_value_as_integer_and_option_value_is_string
-    albums = [ Album.new("1", "first","rap"), Album.new("2", "second","pop")]
-
-    assert_dom_equal(
-    %(<option selected="selected" value="1">rap</option>\n<option value="2">pop</option>),
-    options_from_collection_for_select(albums, "id", "genre", :selected => 1)
-    )
-  end
-
-  def test_collection_options_with_preselected_value_as_string_and_option_value_is_float
-    albums = [ Album.new(1.0, "first","rap"), Album.new(2.0, "second","pop")]
-
-    assert_dom_equal(
-    %(<option value="1.0">rap</option>\n<option value="2.0" selected="selected">pop</option>),
-    options_from_collection_for_select(albums, "id", "genre", :selected => "2.0")
-    )
-  end
-
-  def test_collection_options_with_preselected_value_as_nil
-    albums = [ Album.new(1.0, "first","rap"), Album.new(2.0, "second","pop")]
-
-    assert_dom_equal(
-    %(<option value="1.0">rap</option>\n<option value="2.0">pop</option>),
-    options_from_collection_for_select(albums, "id", "genre", :selected => nil)
-    )
-  end
-
-  def test_collection_options_with_disabled_value_as_nil
-    albums = [ Album.new(1.0, "first","rap"), Album.new(2.0, "second","pop")]
-
-    assert_dom_equal(
-    %(<option value="1.0">rap</option>\n<option value="2.0">pop</option>),
-    options_from_collection_for_select(albums, "id", "genre", :disabled => nil)
-    )
-  end
-
-  def test_collection_options_with_disabled_value_as_array
-    albums = [ Album.new(1.0, "first","rap"), Album.new(2.0, "second","pop")]
-
-    assert_dom_equal(
-    %(<option disabled="disabled" value="1.0">rap</option>\n<option disabled="disabled" value="2.0">pop</option>),
-    options_from_collection_for_select(albums, "id", "genre", :disabled => ["1.0", 2.0])
-    )
-  end
-
-  def test_collection_options_with_preselected_values_as_string_array_and_option_value_is_float
-    albums = [ Album.new(1.0, "first","rap"), Album.new(2.0, "second","pop"), Album.new(3.0, "third","country") ]
-
-    assert_dom_equal(
-    %(<option value="1.0" selected="selected">rap</option>\n<option value="2.0">pop</option>\n<option value="3.0" selected="selected">country</option>),
-    options_from_collection_for_select(albums, "id", "genre", ["1.0","3.0"])
-    )
-  end
-
-  def test_option_groups_from_collection_for_select
-    assert_dom_equal(
-      "<optgroup label=\"&lt;Africa&gt;\"><option value=\"&lt;sa&gt;\">&lt;South Africa&gt;</option>\n<option value=\"so\">Somalia</option></optgroup><optgroup label=\"Europe\"><option value=\"dk\" selected=\"selected\">Denmark</option>\n<option value=\"ie\">Ireland</option></optgroup>",
-      option_groups_from_collection_for_select(dummy_continents, "countries", "continent_name", "country_id", "country_name", "dk")
-    )
-  end
-
-  def test_option_groups_from_collection_for_select_returns_html_safe_string
-    assert option_groups_from_collection_for_select(dummy_continents, "countries", "continent_name", "country_id", "country_name", "dk").html_safe?
-  end
-
-  def test_grouped_options_for_select_with_array
-    assert_dom_equal(
-      "<optgroup label=\"North America\"><option value=\"US\">United States</option>\n<option value=\"Canada\">Canada</option></optgroup><optgroup label=\"Europe\"><option value=\"GB\">Great Britain</option>\n<option value=\"Germany\">Germany</option></optgroup>",
-      grouped_options_for_select([
-         ["North America",
-             [['United States','US'],"Canada"]],
-         ["Europe",
-             [["Great Britain","GB"], "Germany"]]
-       ])
-    )
-  end
-
-  def test_grouped_options_for_select_with_optional_divider
-    assert_dom_equal(
-      "<optgroup label=\"----------\"><option value=\"US\">US</option>\n<option value=\"Canada\">Canada</option></optgroup><optgroup label=\"----------\"><option value=\"GB\">GB</option>\n<option value=\"Germany\">Germany</option></optgroup>",
-
-      grouped_options_for_select([['US',"Canada"] , ["GB", "Germany"]], nil, divider: "----------")
-    )
-  end
-
-  def test_grouped_options_for_select_with_selected_and_prompt_deprecated
-    assert_deprecated 'Passing the prompt to grouped_options_for_select as an argument is deprecated. Please use an options hash like `{ prompt: "Choose a product..." }`.' do
-      assert_dom_equal(
-        "<option value=\"\">Choose a product...</option><optgroup label=\"Hats\"><option value=\"Baseball Cap\">Baseball Cap</option>\n<option selected=\"selected\" value=\"Cowboy Hat\">Cowboy Hat</option></optgroup>",
-        grouped_options_for_select([["Hats", ["Baseball Cap","Cowboy Hat"]]], "Cowboy Hat", "Choose a product...")
-      )
-    end
-  end
-
-  def test_grouped_options_for_select_with_selected_and_prompt
-    assert_dom_equal(
-        "<option value=\"\">Choose a product...</option><optgroup label=\"Hats\"><option value=\"Baseball Cap\">Baseball Cap</option>\n<option selected=\"selected\" value=\"Cowboy Hat\">Cowboy Hat</option></optgroup>",
-        grouped_options_for_select([["Hats", ["Baseball Cap","Cowboy Hat"]]], "Cowboy Hat", prompt: "Choose a product...")
-    )
-  end
-
-  def test_grouped_options_for_select_with_selected_and_prompt_true
-    assert_dom_equal(
-        "<option value=\"\">Please select</option><optgroup label=\"Hats\"><option value=\"Baseball Cap\">Baseball Cap</option>\n<option selected=\"selected\" value=\"Cowboy Hat\">Cowboy Hat</option></optgroup>",
-        grouped_options_for_select([["Hats", ["Baseball Cap","Cowboy Hat"]]], "Cowboy Hat", prompt: true)
-    )
-  end
-
-  def test_grouped_options_for_select_returns_html_safe_string
-    assert grouped_options_for_select([["Hats", ["Baseball Cap","Cowboy Hat"]]]).html_safe?
-  end
-
-  def test_grouped_options_for_select_with_prompt_returns_html_escaped_string_deprecated
-    ActiveSupport::Deprecation.silence do
-      assert_dom_equal(
-        "<option value=\"\">&lt;Choose One&gt;</option><optgroup label=\"Hats\"><option value=\"Baseball Cap\">Baseball Cap</option>\n<option value=\"Cowboy Hat\">Cowboy Hat</option></optgroup>",
-        grouped_options_for_select([["Hats", ["Baseball Cap","Cowboy Hat"]]], nil, '<Choose One>'))
-    end
-  end
-
-  def test_grouped_options_for_select_with_prompt_returns_html_escaped_string
-    assert_dom_equal(
-      "<option value=\"\">&lt;Choose One&gt;</option><optgroup label=\"Hats\"><option value=\"Baseball Cap\">Baseball Cap</option>\n<option value=\"Cowboy Hat\">Cowboy Hat</option></optgroup>",
-      grouped_options_for_select([["Hats", ["Baseball Cap","Cowboy Hat"]]], nil, prompt: '<Choose One>'))
-  end
-
-  def test_optgroups_with_with_options_with_hash
-    assert_dom_equal(
-       "<optgroup label=\"North America\"><option value=\"United States\">United States</option>\n<option value=\"Canada\">Canada</option></optgroup><optgroup label=\"Europe\"><option value=\"Denmark\">Denmark</option>\n<option value=\"Germany\">Germany</option></optgroup>",
-       grouped_options_for_select({'North America' => ['United States','Canada'], 'Europe' => ['Denmark','Germany']})
-    )
-  end
-
-  def test_time_zone_options_no_params
-    opts = time_zone_options_for_select
-    assert_dom_equal "<option value=\"A\">A</option>\n" +
-                 "<option value=\"B\">B</option>\n" +
-                 "<option value=\"C\">C</option>\n" +
-                 "<option value=\"D\">D</option>\n" +
-                 "<option value=\"E\">E</option>",
-                 opts
-  end
-
-  def test_time_zone_options_with_selected
-    opts = time_zone_options_for_select( "D" )
-    assert_dom_equal "<option value=\"A\">A</option>\n" +
-                 "<option value=\"B\">B</option>\n" +
-                 "<option value=\"C\">C</option>\n" +
-                 "<option value=\"D\" selected=\"selected\">D</option>\n" +
-                 "<option value=\"E\">E</option>",
-                 opts
-  end
-
-  def test_time_zone_options_with_unknown_selected
-    opts = time_zone_options_for_select( "K" )
-    assert_dom_equal "<option value=\"A\">A</option>\n" +
-                 "<option value=\"B\">B</option>\n" +
-                 "<option value=\"C\">C</option>\n" +
-                 "<option value=\"D\">D</option>\n" +
-                 "<option value=\"E\">E</option>",
-                 opts
-  end
-
-  def test_time_zone_options_with_priority_zones
-    zones = [ ActiveSupport::TimeZone.new( "B" ), ActiveSupport::TimeZone.new( "E" ) ]
-    opts = time_zone_options_for_select( nil, zones )
-    assert_dom_equal "<option value=\"B\">B</option>\n" +
-                 "<option value=\"E\">E</option>" +
-                 "<option value=\"\" disabled=\"disabled\">-------------</option>\n" +
-                 "<option value=\"A\">A</option>\n" +
-                 "<option value=\"C\">C</option>\n" +
-                 "<option value=\"D\">D</option>",
-                 opts
-  end
-
-  def test_time_zone_options_with_selected_priority_zones
-    zones = [ ActiveSupport::TimeZone.new( "B" ), ActiveSupport::TimeZone.new( "E" ) ]
-    opts = time_zone_options_for_select( "E", zones )
-    assert_dom_equal "<option value=\"B\">B</option>\n" +
-                 "<option value=\"E\" selected=\"selected\">E</option>" +
-                 "<option value=\"\" disabled=\"disabled\">-------------</option>\n" +
-                 "<option value=\"A\">A</option>\n" +
-                 "<option value=\"C\">C</option>\n" +
-                 "<option value=\"D\">D</option>",
-                 opts
-  end
-
-  def test_time_zone_options_with_unselected_priority_zones
-    zones = [ ActiveSupport::TimeZone.new( "B" ), ActiveSupport::TimeZone.new( "E" ) ]
-    opts = time_zone_options_for_select( "C", zones )
-    assert_dom_equal "<option value=\"B\">B</option>\n" +
-                 "<option value=\"E\">E</option>" +
-                 "<option value=\"\" disabled=\"disabled\">-------------</option>\n" +
-                 "<option value=\"A\">A</option>\n" +
-                 "<option value=\"C\" selected=\"selected\">C</option>\n" +
-                 "<option value=\"D\">D</option>",
-                 opts
-  end
-
-  def test_time_zone_options_with_priority_zones_does_not_mutate_time_zones
-    original_zones = ActiveSupport::TimeZone.all.dup
-    zones = [ ActiveSupport::TimeZone.new( "B" ), ActiveSupport::TimeZone.new( "E" ) ]
-    time_zone_options_for_select(nil, zones)
-    assert_equal original_zones, ActiveSupport::TimeZone.all
-  end
-
-  def test_time_zone_options_returns_html_safe_string
-    assert time_zone_options_for_select.html_safe?
-  end
-
-  def test_select
-    @post = Post.new
-    @post.category = "<mus>"
-    assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"abe\">abe</option>\n<option value=\"&lt;mus&gt;\" selected=\"selected\">&lt;mus&gt;</option>\n<option value=\"hest\">hest</option></select>",
-      select("post", "category", %w( abe <mus> hest))
-    )
-  end
-
-  def test_select_without_multiple
-    assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"></select>",
-      select(:post, :category, "", {}, :multiple => false)
-    )
-  end
-
-  def test_select_with_grouped_collection_as_nested_array
-    @post = Post.new
-
-    countries_by_continent = [
-      ["<Africa>", [["<South Africa>", "<sa>"], ["Somalia", "so"]]],
-      ["Europe",   [["Denmark", "dk"], ["Ireland", "ie"]]],
-    ]
-
-    assert_dom_equal(
-      [
-        %Q{<select id="post_origin" name="post[origin]"><optgroup label="&lt;Africa&gt;"><option value="&lt;sa&gt;">&lt;South Africa&gt;</option>},
-        %Q{<option value="so">Somalia</option></optgroup><optgroup label="Europe"><option value="dk">Denmark</option>},
-        %Q{<option value="ie">Ireland</option></optgroup></select>},
-      ].join("\n"),
-      select("post", "origin", countries_by_continent)
-    )
-  end
-
-  def test_select_with_grouped_collection_as_hash
-    @post = Post.new
-
-    countries_by_continent = {
-      "<Africa>" => [["<South Africa>", "<sa>"], ["Somalia", "so"]],
-      "Europe"   => [["Denmark", "dk"], ["Ireland", "ie"]],
-    }
-
-    assert_dom_equal(
-      [
-        %Q{<select id="post_origin" name="post[origin]"><optgroup label="&lt;Africa&gt;"><option value="&lt;sa&gt;">&lt;South Africa&gt;</option>},
-        %Q{<option value="so">Somalia</option></optgroup><optgroup label="Europe"><option value="dk">Denmark</option>},
-        %Q{<option value="ie">Ireland</option></optgroup></select>},
-      ].join("\n"),
-      select("post", "origin", countries_by_continent)
-    )
-  end
-
-  def test_select_with_boolean_method
-    @post = Post.new
-    @post.allow_comments = false
-    assert_dom_equal(
-      "<select id=\"post_allow_comments\" name=\"post[allow_comments]\"><option value=\"true\">true</option>\n<option value=\"false\" selected=\"selected\">false</option></select>",
-      select("post", "allow_comments", %w( true false ))
-    )
-  end
-
-  def test_select_under_fields_for
-    @post = Post.new
-    @post.category = "<mus>"
-
-    output_buffer = fields_for :post, @post do |f|
-      concat f.select(:category, %w( abe <mus> hest))
-    end
-
-    assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"abe\">abe</option>\n<option value=\"&lt;mus&gt;\" selected=\"selected\">&lt;mus&gt;</option>\n<option value=\"hest\">hest</option></select>",
-      output_buffer
-    )
-  end
-
-  def test_fields_for_with_record_inherited_from_hash
-    map = Map.new
-
-    output_buffer = fields_for :map, map do |f|
-      concat f.select(:category, %w( abe <mus> hest))
-    end
-
-    assert_dom_equal(
-      "<select id=\"map_category\" name=\"map[category]\"><option value=\"abe\">abe</option>\n<option value=\"&lt;mus&gt;\" selected=\"selected\">&lt;mus&gt;</option>\n<option value=\"hest\">hest</option></select>",
-      output_buffer
-    )
-  end
-
-  def test_select_under_fields_for_with_index
-    @post = Post.new
-    @post.category = "<mus>"
-
-    output_buffer = fields_for :post, @post, :index => 108 do |f|
-      concat f.select(:category, %w( abe <mus> hest))
-    end
-
-    assert_dom_equal(
-      "<select id=\"post_108_category\" name=\"post[108][category]\"><option value=\"abe\">abe</option>\n<option value=\"&lt;mus&gt;\" selected=\"selected\">&lt;mus&gt;</option>\n<option value=\"hest\">hest</option></select>",
-      output_buffer
-    )
-  end
-
-  def test_select_under_fields_for_with_auto_index
-    @post = Post.new
-    @post.category = "<mus>"
-    def @post.to_param; 108; end
-
-    output_buffer = fields_for "post[]", @post do |f|
-      concat f.select(:category, %w( abe <mus> hest))
-    end
-
-    assert_dom_equal(
-      "<select id=\"post_108_category\" name=\"post[108][category]\"><option value=\"abe\">abe</option>\n<option value=\"&lt;mus&gt;\" selected=\"selected\">&lt;mus&gt;</option>\n<option value=\"hest\">hest</option></select>",
-      output_buffer
-    )
-  end
-
-  def test_select_under_fields_for_with_string_and_given_prompt
-    @post = Post.new
-    options = "<option value=\"abe\">abe</option><option value=\"mus\">mus</option><option value=\"hest\">hest</option>".html_safe
-
-    output_buffer = fields_for :post, @post do |f|
-      concat f.select(:category, options, :prompt => 'The prompt')
-    end
-
-    assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\">The prompt</option>\n#{options}</select>",
-      output_buffer
-    )
-  end
-
-  def test_select_with_multiple_to_add_hidden_input
-    output_buffer =  select(:post, :category, "", {}, :multiple => true)
-    assert_dom_equal(
-      "<input type=\"hidden\" name=\"post[category][]\" value=\"\"/><select multiple=\"multiple\" id=\"post_category\" name=\"post[category][]\"></select>",
-      output_buffer
-    )
-  end
-
-  def test_select_with_multiple_and_without_hidden_input
-    output_buffer =  select(:post, :category, "", {:include_hidden => false}, :multiple => true)
-    assert_dom_equal(
-      "<select multiple=\"multiple\" id=\"post_category\" name=\"post[category][]\"></select>",
-      output_buffer
-    )
-  end
-
-  def test_select_with_multiple_and_with_explicit_name_ending_with_brackets
-    output_buffer =  select(:post, :category, [], {include_hidden: false}, multiple: true, name: 'post[category][]')
-    assert_dom_equal(
-      "<select multiple=\"multiple\" id=\"post_category\" name=\"post[category][]\"></select>",
-      output_buffer
-    )
-  end
-
-  def test_select_with_multiple_and_disabled_to_add_disabled_hidden_input
-    output_buffer =  select(:post, :category, "", {}, :multiple => true, :disabled => true)
-    assert_dom_equal(
-      "<input disabled=\"disabled\"type=\"hidden\" name=\"post[category][]\" value=\"\"/><select multiple=\"multiple\" disabled=\"disabled\" id=\"post_category\" name=\"post[category][]\"></select>",
-      output_buffer
-    )
-  end
-
-  def test_select_with_blank
-    @post = Post.new
-    @post.category = "<mus>"
-    assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\"></option>\n<option value=\"abe\">abe</option>\n<option value=\"&lt;mus&gt;\" selected=\"selected\">&lt;mus&gt;</option>\n<option value=\"hest\">hest</option></select>",
-      select("post", "category", %w( abe <mus> hest), :include_blank => true)
-    )
-  end
-
-  def test_select_with_blank_as_string
-    @post = Post.new
-    @post.category = "<mus>"
-    assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\">None</option>\n<option value=\"abe\">abe</option>\n<option value=\"&lt;mus&gt;\" selected=\"selected\">&lt;mus&gt;</option>\n<option value=\"hest\">hest</option></select>",
-      select("post", "category", %w( abe <mus> hest), :include_blank => 'None')
-    )
-  end
-
-  def test_select_with_blank_as_string_escaped
-    @post = Post.new
-    @post.category = "<mus>"
-    assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\">&lt;None&gt;</option>\n<option value=\"abe\">abe</option>\n<option value=\"&lt;mus&gt;\" selected=\"selected\">&lt;mus&gt;</option>\n<option value=\"hest\">hest</option></select>",
-      select("post", "category", %w( abe <mus> hest), :include_blank => '<None>')
-    )
-  end
-
-  def test_select_with_default_prompt
-    @post = Post.new
-    @post.category = ""
-    assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\">Please select</option>\n<option value=\"abe\">abe</option>\n<option value=\"&lt;mus&gt;\">&lt;mus&gt;</option>\n<option value=\"hest\">hest</option></select>",
-      select("post", "category", %w( abe <mus> hest), :prompt => true)
-    )
-  end
-
-  def test_select_no_prompt_when_select_has_value
-    @post = Post.new
-    @post.category = "<mus>"
-    assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"abe\">abe</option>\n<option value=\"&lt;mus&gt;\" selected=\"selected\">&lt;mus&gt;</option>\n<option value=\"hest\">hest</option></select>",
-      select("post", "category", %w( abe <mus> hest), :prompt => true)
-    )
-  end
-
-  def test_select_with_given_prompt
-    @post = Post.new
-    @post.category = ""
-    assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\">The prompt</option>\n<option value=\"abe\">abe</option>\n<option value=\"&lt;mus&gt;\">&lt;mus&gt;</option>\n<option value=\"hest\">hest</option></select>",
-      select("post", "category", %w( abe <mus> hest), :prompt => 'The prompt')
-    )
-  end
-
-  def test_select_with_given_prompt_escaped
-    @post = Post.new
-    assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\">&lt;The prompt&gt;</option>\n<option value=\"abe\">abe</option>\n<option value=\"&lt;mus&gt;\">&lt;mus&gt;</option>\n<option value=\"hest\">hest</option></select>",
-      select("post", "category", %w( abe <mus> hest), :prompt => '<The prompt>')
-    )
-  end
-
-  def test_select_with_prompt_and_blank
-    @post = Post.new
-    @post.category = ""
-    assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\">Please select</option>\n<option value=\"\"></option>\n<option value=\"abe\">abe</option>\n<option value=\"&lt;mus&gt;\">&lt;mus&gt;</option>\n<option value=\"hest\">hest</option></select>",
-      select("post", "category", %w( abe <mus> hest), :prompt => true, :include_blank => true)
-    )
-  end
-
-  def test_empty
-    @post = Post.new
-    @post.category = ""
-    assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\">Please select</option>\n<option value=\"\"></option>\n</select>",
-      select("post", "category", [], :prompt => true, :include_blank => true)
-    )
-  end
-
-  def test_select_with_nil
-    @post = Post.new
-    @post.category = "othervalue"
-    assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\"></option>\n<option value=\"othervalue\" selected=\"selected\">othervalue</option></select>",
-      select("post", "category", [nil, "othervalue"])
-    )
-  end
-
-  def test_required_select
-    assert_dom_equal(
-      %(<select id="post_category" name="post[category]" required="required"><option value=""></option>\n<option value="abe">abe</option>\n<option value="mus">mus</option>\n<option value="hest">hest</option></select>),
-      select("post", "category", %w(abe mus hest), {}, required: true)
-    )
-  end
-
-  def test_required_select_with_include_blank_prompt
-    assert_dom_equal(
-      %(<select id="post_category" name="post[category]" required="required"><option value="">Select one</option>\n<option value="abe">abe</option>\n<option value="mus">mus</option>\n<option value="hest">hest</option></select>),
-      select("post", "category", %w(abe mus hest), { include_blank: "Select one" }, required: true)
-    )
-  end
-
-  def test_required_select_with_prompt
-    assert_dom_equal(
-      %(<select id="post_category" name="post[category]" required="required"><option value="">Select one</option>\n<option value="abe">abe</option>\n<option value="mus">mus</option>\n<option value="hest">hest</option></select>),
-      select("post", "category", %w(abe mus hest), { prompt: "Select one" }, required: true)
-    )
-  end
-
-  def test_required_select_display_size_equals_to_one
-    assert_dom_equal(
-      %(<select id="post_category" name="post[category]" required="required" size="1"><option value=""></option>\n<option value="abe">abe</option>\n<option value="mus">mus</option>\n<option value="hest">hest</option></select>),
-      select("post", "category", %w(abe mus hest), {}, required: true, size: 1)
-    )
-  end
-
-  def test_required_select_with_display_size_bigger_than_one
-    assert_dom_equal(
-      %(<select id="post_category" name="post[category]" required="required" size="2"><option value="abe">abe</option>\n<option value="mus">mus</option>\n<option value="hest">hest</option></select>),
-      select("post", "category", %w(abe mus hest), {}, required: true, size: 2)
-    )
-  end
-
-  def test_required_select_with_multiple_option
-    assert_dom_equal(
-      %(<input name="post[category][]" type="hidden" value=""/><select id="post_category" multiple="multiple" name="post[category][]" required="required"><option value="abe">abe</option>\n<option value="mus">mus</option>\n<option value="hest">hest</option></select>),
-      select("post", "category", %w(abe mus hest), {}, required: true, multiple: true)
-    )
-  end
-
-  def test_select_with_fixnum
-    @post = Post.new
-    @post.category = ""
-    assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\">Please select</option>\n<option value=\"\"></option>\n<option value=\"1\">1</option></select>",
-      select("post", "category", [1], :prompt => true, :include_blank => true)
-    )
-  end
-
-  def test_list_of_lists
-    @post = Post.new
-    @post.category = ""
-    assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\">Please select</option>\n<option value=\"\"></option>\n<option value=\"number\">Number</option>\n<option value=\"text\">Text</option>\n<option value=\"boolean\">Yes/No</option></select>",
-      select("post", "category", [["Number", "number"], ["Text", "text"], ["Yes/No", "boolean"]], :prompt => true, :include_blank => true)
-    )
-  end
-
-  def test_select_with_selected_value
-    @post = Post.new
-    @post.category = "<mus>"
-    assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"abe\" selected=\"selected\">abe</option>\n<option value=\"&lt;mus&gt;\">&lt;mus&gt;</option>\n<option value=\"hest\">hest</option></select>",
-      select("post", "category", %w( abe <mus> hest ), :selected => 'abe')
-    )
-  end
-
-  def test_select_with_index_option
-    @album = Album.new
-    @album.id = 1
-
-    expected = "<select id=\"album__genre\" name=\"album[][genre]\"><option value=\"rap\">rap</option>\n<option value=\"rock\">rock</option>\n<option value=\"country\">country</option></select>"
-
-    assert_dom_equal(
-      expected,
-      select("album[]", "genre", %w[rap rock country], {}, { :index => nil })
-    )
-  end
-
-  def test_select_escapes_options
-    assert_dom_equal(
-      '<select id="post_title" name="post[title]">&lt;script&gt;alert(1)&lt;/script&gt;</select>',
-      select('post', 'title', '<script>alert(1)</script>')
-    )
-  end
-
-  def test_select_with_selected_nil
-    @post = Post.new
-    @post.category = "<mus>"
-    assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"abe\">abe</option>\n<option value=\"&lt;mus&gt;\">&lt;mus&gt;</option>\n<option value=\"hest\">hest</option></select>",
-      select("post", "category", %w( abe <mus> hest ), :selected => nil)
-    )
-  end
-
-  def test_select_with_disabled_value
-    @post = Post.new
-    @post.category = "<mus>"
-    assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"abe\">abe</option>\n<option value=\"&lt;mus&gt;\" selected=\"selected\">&lt;mus&gt;</option>\n<option value=\"hest\" disabled=\"disabled\">hest</option></select>",
-      select("post", "category", %w( abe <mus> hest ), :disabled => 'hest')
-    )
-  end
-
-  def test_select_with_disabled_array
-    @post = Post.new
-    @post.category = "<mus>"
-    assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"abe\" disabled=\"disabled\">abe</option>\n<option value=\"&lt;mus&gt;\" selected=\"selected\">&lt;mus&gt;</option>\n<option value=\"hest\" disabled=\"disabled\">hest</option></select>",
-      select("post", "category", %w( abe <mus> hest ), :disabled => ['hest', 'abe'])
-    )
-  end
-
-  def test_select_with_range
-    @post = Post.new
-    @post.category = 0
-    assert_dom_equal(
-      "<select id=\"post_category\" name=\"post[category]\"><option value=\"1\">1</option>\n<option value=\"2\">2</option>\n<option value=\"3\">3</option></select>",
-      select("post", "category", 1..3)
-    )
-  end
-
-  def test_collection_select
-    @post = Post.new
-    @post.author_name = "Babe"
-
-    assert_dom_equal(
-      "<select id=\"post_author_name\" name=\"post[author_name]\"><option value=\"&lt;Abe&gt;\">&lt;Abe&gt;</option>\n<option value=\"Babe\" selected=\"selected\">Babe</option>\n<option value=\"Cabe\">Cabe</option></select>",
-      collection_select("post", "author_name", dummy_posts, "author_name", "author_name")
-    )
-  end
-
-  def test_collection_select_under_fields_for
-    @post = Post.new
-    @post.author_name = "Babe"
-
-    output_buffer = fields_for :post, @post do |f|
-      concat f.collection_select(:author_name, dummy_posts, :author_name, :author_name)
-    end
-
-    assert_dom_equal(
-      "<select id=\"post_author_name\" name=\"post[author_name]\"><option value=\"&lt;Abe&gt;\">&lt;Abe&gt;</option>\n<option value=\"Babe\" selected=\"selected\">Babe</option>\n<option value=\"Cabe\">Cabe</option></select>",
-      output_buffer
-    )
-  end
-
-  def test_collection_select_under_fields_for_with_index
-    @post = Post.new
-    @post.author_name = "Babe"
-
-    output_buffer = fields_for :post, @post, :index => 815 do |f|
-      concat f.collection_select(:author_name, dummy_posts, :author_name, :author_name)
-    end
-
-    assert_dom_equal(
-      "<select id=\"post_815_author_name\" name=\"post[815][author_name]\"><option value=\"&lt;Abe&gt;\">&lt;Abe&gt;</option>\n<option value=\"Babe\" selected=\"selected\">Babe</option>\n<option value=\"Cabe\">Cabe</option></select>",
-      output_buffer
-    )
-  end
-
-  def test_collection_select_under_fields_for_with_auto_index
-    @post = Post.new
-    @post.author_name = "Babe"
-    def @post.to_param; 815; end
-
-    output_buffer = fields_for "post[]", @post do |f|
-      concat f.collection_select(:author_name, dummy_posts, :author_name, :author_name)
-    end
-
-    assert_dom_equal(
-      "<select id=\"post_815_author_name\" name=\"post[815][author_name]\"><option value=\"&lt;Abe&gt;\">&lt;Abe&gt;</option>\n<option value=\"Babe\" selected=\"selected\">Babe</option>\n<option value=\"Cabe\">Cabe</option></select>",
-      output_buffer
-    )
-  end
-
-  def test_collection_select_with_blank_and_style
-    @post = Post.new
-    @post.author_name = "Babe"
-
-    assert_dom_equal(
-      "<select id=\"post_author_name\" name=\"post[author_name]\" style=\"width: 200px\"><option value=\"\"></option>\n<option value=\"&lt;Abe&gt;\">&lt;Abe&gt;</option>\n<option value=\"Babe\" selected=\"selected\">Babe</option>\n<option value=\"Cabe\">Cabe</option></select>",
-      collection_select("post", "author_name", dummy_posts, "author_name", "author_name", { :include_blank => true }, "style" => "width: 200px")
-    )
-  end
-
-  def test_collection_select_with_blank_as_string_and_style
-    @post = Post.new
-    @post.author_name = "Babe"
-
-    assert_dom_equal(
-      "<select id=\"post_author_name\" name=\"post[author_name]\" style=\"width: 200px\"><option value=\"\">No Selection</option>\n<option value=\"&lt;Abe&gt;\">&lt;Abe&gt;</option>\n<option value=\"Babe\" selected=\"selected\">Babe</option>\n<option value=\"Cabe\">Cabe</option></select>",
-      collection_select("post", "author_name", dummy_posts, "author_name", "author_name", { :include_blank => 'No Selection' }, "style" => "width: 200px")
-    )
-  end
-
-  def test_collection_select_with_multiple_option_appends_array_brackets_and_hidden_input
-    @post = Post.new
-    @post.author_name = "Babe"
-
-    expected = "<input type=\"hidden\" name=\"post[author_name][]\" value=\"\"/><select id=\"post_author_name\" name=\"post[author_name][]\" multiple=\"multiple\"><option value=\"\"></option>\n<option value=\"&lt;Abe&gt;\">&lt;Abe&gt;</option>\n<option value=\"Babe\" selected=\"selected\">Babe</option>\n<option value=\"Cabe\">Cabe</option></select>"
-
-    # Should suffix default name with [].
-    assert_dom_equal expected, collection_select("post", "author_name", dummy_posts, "author_name", "author_name", { :include_blank => true }, :multiple => true)
-
-    # Shouldn't suffix custom name with [].
-    assert_dom_equal expected, collection_select("post", "author_name", dummy_posts, "author_name", "author_name", { :include_blank => true, :name => 'post[author_name][]' }, :multiple => true)
-  end
-
-  def test_collection_select_with_blank_and_selected
-    @post = Post.new
-    @post.author_name = "Babe"
-
-    assert_dom_equal(
-      %{<select id="post_author_name" name="post[author_name]"><option value=""></option>\n<option value="&lt;Abe&gt;" selected="selected">&lt;Abe&gt;</option>\n<option value="Babe">Babe</option>\n<option value="Cabe">Cabe</option></select>},
-      collection_select("post", "author_name", dummy_posts, "author_name", "author_name", {:include_blank => true, :selected => "<Abe>"})
-    )
-  end
-
-  def test_collection_select_with_disabled
-    @post = Post.new
-    @post.author_name = "Babe"
-
-    assert_dom_equal(
-      "<select id=\"post_author_name\" name=\"post[author_name]\"><option value=\"&lt;Abe&gt;\">&lt;Abe&gt;</option>\n<option value=\"Babe\" selected=\"selected\">Babe</option>\n<option value=\"Cabe\" disabled=\"disabled\">Cabe</option></select>",
-      collection_select("post", "author_name", dummy_posts, "author_name", "author_name", :disabled => 'Cabe')
-    )
-  end
-
-  def test_collection_select_with_proc_for_value_method
-    @post = Post.new
-
-    assert_dom_equal(
-      "<select id=\"post_author_name\" name=\"post[author_name]\"><option value=\"&lt;Abe&gt;\">&lt;Abe&gt; went home</option>\n<option value=\"Babe\">Babe went home</option>\n<option value=\"Cabe\">Cabe went home</option></select>",
-      collection_select("post", "author_name", dummy_posts, lambda { |p| p.author_name }, "title")
-    )
-  end
-
-  def test_collection_select_with_proc_for_text_method
-    @post = Post.new
-
-    assert_dom_equal(
-      "<select id=\"post_author_name\" name=\"post[author_name]\"><option value=\"&lt;Abe&gt;\">&lt;Abe&gt; went home</option>\n<option value=\"Babe\">Babe went home</option>\n<option value=\"Cabe\">Cabe went home</option></select>",
-      collection_select("post", "author_name", dummy_posts, "author_name", lambda { |p| p.title })
-    )
-  end
-
-  def test_time_zone_select
-    @firm = Firm.new("D")
-    html = time_zone_select( "firm", "time_zone" )
-    assert_dom_equal "<select id=\"firm_time_zone\" name=\"firm[time_zone]\">" +
-                 "<option value=\"A\">A</option>\n" +
-                 "<option value=\"B\">B</option>\n" +
-                 "<option value=\"C\">C</option>\n" +
-                 "<option value=\"D\" selected=\"selected\">D</option>\n" +
-                 "<option value=\"E\">E</option>" +
-                 "</select>",
-                 html
-  end
-
-  def test_time_zone_select_under_fields_for
-    @firm = Firm.new("D")
-
-    output_buffer = fields_for :firm, @firm do |f|
-      concat f.time_zone_select(:time_zone)
-    end
-
-    assert_dom_equal(
-      "<select id=\"firm_time_zone\" name=\"firm[time_zone]\">" +
-      "<option value=\"A\">A</option>\n" +
-      "<option value=\"B\">B</option>\n" +
-      "<option value=\"C\">C</option>\n" +
-      "<option value=\"D\" selected=\"selected\">D</option>\n" +
-      "<option value=\"E\">E</option>" +
-      "</select>",
-      output_buffer
-    )
-  end
-
-  def test_time_zone_select_under_fields_for_with_index
-    @firm = Firm.new("D")
-
-    output_buffer = fields_for :firm, @firm, :index => 305 do |f|
-      concat f.time_zone_select(:time_zone)
-    end
-
-    assert_dom_equal(
-      "<select id=\"firm_305_time_zone\" name=\"firm[305][time_zone]\">" +
-      "<option value=\"A\">A</option>\n" +
-      "<option value=\"B\">B</option>\n" +
-      "<option value=\"C\">C</option>\n" +
-      "<option value=\"D\" selected=\"selected\">D</option>\n" +
-      "<option value=\"E\">E</option>" +
-      "</select>",
-      output_buffer
-    )
-  end
-
-  def test_time_zone_select_under_fields_for_with_auto_index
-    @firm = Firm.new("D")
-    def @firm.to_param; 305; end
-
-    output_buffer = fields_for "firm[]", @firm do |f|
-      concat f.time_zone_select(:time_zone)
-    end
-
-    assert_dom_equal(
-      "<select id=\"firm_305_time_zone\" name=\"firm[305][time_zone]\">" +
-      "<option value=\"A\">A</option>\n" +
-      "<option value=\"B\">B</option>\n" +
-      "<option value=\"C\">C</option>\n" +
-      "<option value=\"D\" selected=\"selected\">D</option>\n" +
-      "<option value=\"E\">E</option>" +
-      "</select>",
-      output_buffer
-    )
-  end
-
-  def test_time_zone_select_with_blank
-    @firm = Firm.new("D")
-    html = time_zone_select("firm", "time_zone", nil, :include_blank => true)
-    assert_dom_equal "<select id=\"firm_time_zone\" name=\"firm[time_zone]\">" +
-                 "<option value=\"\"></option>\n" +
-                 "<option value=\"A\">A</option>\n" +
-                 "<option value=\"B\">B</option>\n" +
-                 "<option value=\"C\">C</option>\n" +
-                 "<option value=\"D\" selected=\"selected\">D</option>\n" +
-                 "<option value=\"E\">E</option>" +
-                 "</select>",
-                 html
-  end
-
-  def test_time_zone_select_with_blank_as_string
-    @firm = Firm.new("D")
-    html = time_zone_select("firm", "time_zone", nil, :include_blank => 'No Zone')
-    assert_dom_equal "<select id=\"firm_time_zone\" name=\"firm[time_zone]\">" +
-                 "<option value=\"\">No Zone</option>\n" +
-                 "<option value=\"A\">A</option>\n" +
-                 "<option value=\"B\">B</option>\n" +
-                 "<option value=\"C\">C</option>\n" +
-                 "<option value=\"D\" selected=\"selected\">D</option>\n" +
-                 "<option value=\"E\">E</option>" +
-                 "</select>",
-                 html
-  end
-
-  def test_time_zone_select_with_style
-    @firm = Firm.new("D")
-    html = time_zone_select("firm", "time_zone", nil, {},
-      "style" => "color: red")
-    assert_dom_equal "<select id=\"firm_time_zone\" name=\"firm[time_zone]\" style=\"color: red\">" +
-                 "<option value=\"A\">A</option>\n" +
-                 "<option value=\"B\">B</option>\n" +
-                 "<option value=\"C\">C</option>\n" +
-                 "<option value=\"D\" selected=\"selected\">D</option>\n" +
-                 "<option value=\"E\">E</option>" +
-                 "</select>",
-                 html
-    assert_dom_equal html, time_zone_select("firm", "time_zone", nil, {},
-      :style => "color: red")
-  end
-
-  def test_time_zone_select_with_blank_and_style
-    @firm = Firm.new("D")
-    html = time_zone_select("firm", "time_zone", nil,
-      { :include_blank => true }, "style" => "color: red")
-    assert_dom_equal "<select id=\"firm_time_zone\" name=\"firm[time_zone]\" style=\"color: red\">" +
-                 "<option value=\"\"></option>\n" +
-                 "<option value=\"A\">A</option>\n" +
-                 "<option value=\"B\">B</option>\n" +
-                 "<option value=\"C\">C</option>\n" +
-                 "<option value=\"D\" selected=\"selected\">D</option>\n" +
-                 "<option value=\"E\">E</option>" +
-                 "</select>",
-                 html
-    assert_dom_equal html, time_zone_select("firm", "time_zone", nil,
-      { :include_blank => true }, :style => "color: red")
-  end
-
-  def test_time_zone_select_with_blank_as_string_and_style
-    @firm = Firm.new("D")
-    html = time_zone_select("firm", "time_zone", nil,
-      { :include_blank => 'No Zone' }, "style" => "color: red")
-    assert_dom_equal "<select id=\"firm_time_zone\" name=\"firm[time_zone]\" style=\"color: red\">" +
-                 "<option value=\"\">No Zone</option>\n" +
-                 "<option value=\"A\">A</option>\n" +
-                 "<option value=\"B\">B</option>\n" +
-                 "<option value=\"C\">C</option>\n" +
-                 "<option value=\"D\" selected=\"selected\">D</option>\n" +
-                 "<option value=\"E\">E</option>" +
-                 "</select>",
-                 html
-    assert_dom_equal html, time_zone_select("firm", "time_zone", nil,
-      { :include_blank => 'No Zone' }, :style => "color: red")
-  end
-
-  def test_time_zone_select_with_priority_zones
-    @firm = Firm.new("D")
-    zones = [ ActiveSupport::TimeZone.new("A"), ActiveSupport::TimeZone.new("D") ]
-    html = time_zone_select("firm", "time_zone", zones )
-    assert_dom_equal "<select id=\"firm_time_zone\" name=\"firm[time_zone]\">" +
-                 "<option value=\"A\">A</option>\n" +
-                 "<option value=\"D\" selected=\"selected\">D</option>" +
-                 "<option value=\"\" disabled=\"disabled\">-------------</option>\n" +
-                 "<option value=\"B\">B</option>\n" +
-                 "<option value=\"C\">C</option>\n" +
-                 "<option value=\"E\">E</option>" +
-                 "</select>",
-                 html
-  end
-
-  def test_time_zone_select_with_priority_zones_as_regexp
-    @firm = Firm.new("D")
-
-    @fake_timezones.each_with_index do |tz, i|
-      tz.stubs(:=~).returns(i.zero? || i == 3)
-    end
-
-    html = time_zone_select("firm", "time_zone", /A|D/)
-    assert_dom_equal "<select id=\"firm_time_zone\" name=\"firm[time_zone]\">" +
-                 "<option value=\"A\">A</option>\n" +
-                 "<option value=\"D\" selected=\"selected\">D</option>" +
-                 "<option value=\"\" disabled=\"disabled\">-------------</option>\n" +
-                 "<option value=\"B\">B</option>\n" +
-                 "<option value=\"C\">C</option>\n" +
-                 "<option value=\"E\">E</option>" +
-                 "</select>",
-                 html
-  end
-
-  def test_time_zone_select_with_priority_zones_as_regexp_using_grep_finds_no_zones
-    @firm = Firm.new("D")
-
-    priority_zones = /A|D/
-    @fake_timezones.each do |tz|
-      priority_zones.stubs(:===).with(tz).raises(Exception)
-    end
-
-    html = time_zone_select("firm", "time_zone", priority_zones)
-    assert_dom_equal "<select id=\"firm_time_zone\" name=\"firm[time_zone]\">" +
-                 "<option value=\"\" disabled=\"disabled\">-------------</option>\n" +
-                 "<option value=\"A\">A</option>\n" +
-                 "<option value=\"B\">B</option>\n" +
-                 "<option value=\"C\">C</option>\n" +
-                 "<option value=\"D\" selected=\"selected\">D</option>\n" +
-                 "<option value=\"E\">E</option>" +
-                 "</select>",
-                 html
-  end
-
-  def test_time_zone_select_with_default_time_zone_and_nil_value
-     @firm = Firm.new()
-     @firm.time_zone = nil
-
-     html = time_zone_select( "firm", "time_zone", nil, :default => 'B' )
-     assert_dom_equal "<select id=\"firm_time_zone\" name=\"firm[time_zone]\">" +
-                   "<option value=\"A\">A</option>\n" +
-                   "<option value=\"B\" selected=\"selected\">B</option>\n" +
-                   "<option value=\"C\">C</option>\n" +
-                   "<option value=\"D\">D</option>\n" +
-                   "<option value=\"E\">E</option>" +
-                   "</select>",
-                   html
-  end
-
-  def test_time_zone_select_with_default_time_zone_and_value
-    @firm = Firm.new('D')
-
-    html = time_zone_select( "firm", "time_zone", nil, :default => 'B' )
-    assert_dom_equal "<select id=\"firm_time_zone\" name=\"firm[time_zone]\">" +
-                  "<option value=\"A\">A</option>\n" +
-                  "<option value=\"B\">B</option>\n" +
-                  "<option value=\"C\">C</option>\n" +
-                  "<option value=\"D\" selected=\"selected\">D</option>\n" +
-                  "<option value=\"E\">E</option>" +
-                  "</select>",
-                  html
-  end
-
-  def test_options_for_select_with_element_attributes
-    assert_dom_equal(
-      "<option value=\"&lt;Denmark&gt;\" class=\"bold\">&lt;Denmark&gt;</option>\n<option value=\"USA\" onclick=\"alert(&#39;Hello World&#39;);\">USA</option>\n<option value=\"Sweden\">Sweden</option>\n<option value=\"Germany\">Germany</option>",
-      options_for_select([ [ "<Denmark>", { :class => 'bold' } ], [ "USA", { :onclick => "alert('Hello World');" } ], [ "Sweden" ], "Germany" ])
-    )
-  end
-
-  def test_options_for_select_with_data_element
-    assert_dom_equal(
-      "<option value=\"&lt;Denmark&gt;\" data-test=\"bold\">&lt;Denmark&gt;</option>",
-      options_for_select([ [ "<Denmark>", { :data => { :test => 'bold' } } ] ])
-    )
-  end
-
-  def test_options_for_select_with_data_element_with_special_characters
-    assert_dom_equal(
-      "<option value=\"&lt;Denmark&gt;\" data-test=\"&lt;bold&gt;\">&lt;Denmark&gt;</option>",
-      options_for_select([ [ "<Denmark>", { :data => { :test => '<bold>' } } ] ])
-    )
-  end
-
-  def test_options_for_select_with_element_attributes_and_selection
-    assert_dom_equal(
-      "<option value=\"&lt;Denmark&gt;\">&lt;Denmark&gt;</option>\n<option value=\"USA\" class=\"bold\" selected=\"selected\">USA</option>\n<option value=\"Sweden\">Sweden</option>",
-      options_for_select([ "<Denmark>", [ "USA", { :class => 'bold' } ], "Sweden" ], "USA")
-    )
-  end
-
-  def test_options_for_select_with_element_attributes_and_selection_array
-    assert_dom_equal(
-      "<option value=\"&lt;Denmark&gt;\">&lt;Denmark&gt;</option>\n<option value=\"USA\" class=\"bold\" selected=\"selected\">USA</option>\n<option value=\"Sweden\" selected=\"selected\">Sweden</option>",
-      options_for_select([ "<Denmark>", [ "USA", { :class => 'bold' } ], "Sweden" ], [ "USA", "Sweden" ])
-    )
-  end
-
-  def test_options_for_select_with_special_characters
-    assert_dom_equal(
-      "<option value=\"&lt;Denmark&gt;\" onclick=\"alert(&quot;&lt;code&gt;&quot;)\">&lt;Denmark&gt;</option>",
-      options_for_select([ [ "<Denmark>", { :onclick => %(alert("<code>")) } ] ])
-    )
-  end
-
-  def test_option_html_attributes_with_no_array_element
-    assert_equal({}, option_html_attributes('foo'))
-  end
-
-  def test_option_html_attributes_without_hash
-    assert_equal({}, option_html_attributes([ 'foo', 'bar' ]))
-  end
-
-  def test_option_html_attributes_with_single_element_hash
-    assert_equal(
-      {:class => 'fancy'},
-      option_html_attributes([ 'foo', 'bar', { :class => 'fancy' } ])
-    )
-  end
-
-  def test_option_html_attributes_with_multiple_element_hash
-    assert_equal(
-      {:class => 'fancy', 'onclick' => "alert('Hello World');"},
-      option_html_attributes([ 'foo', 'bar', { :class => 'fancy', 'onclick' => "alert('Hello World');" } ])
-    )
-  end
-
-  def test_option_html_attributes_with_multiple_hashes
-    assert_equal(
-      {:class => 'fancy', 'onclick' => "alert('Hello World');"},
-      option_html_attributes([ 'foo', 'bar', { :class => 'fancy' }, { 'onclick' => "alert('Hello World');" } ])
-    )
-  end
-
-  def test_option_html_attributes_with_multiple_hashes_does_not_modify_them
-    options1 = { class: 'fancy' }
-    options2 = { onclick: "alert('Hello World');" }
-    option_html_attributes([ 'foo', 'bar', options1, options2 ])
-
-    assert_equal({ class: 'fancy' }, options1)
-    assert_equal({ onclick: "alert('Hello World');" }, options2)
-  end
-
-  def test_grouped_collection_select
-    @post = Post.new
-    @post.origin = 'dk'
-
-    assert_dom_equal(
-      %Q{<select id="post_origin" name="post[origin]"><optgroup label="&lt;Africa&gt;"><option value="&lt;sa&gt;">&lt;South Africa&gt;</option>\n<option value="so">Somalia</option></optgroup><optgroup label="Europe"><option value="dk" selected="selected">Denmark</option>\n<option value="ie">Ireland</option></optgroup></select>},
-      grouped_collection_select("post", "origin", dummy_continents, :countries, :continent_name, :country_id, :country_name)
-    )
-  end
-
-  def test_grouped_collection_select_with_selected
-    @post = Post.new
-
-    assert_dom_equal(
-      %Q{<select id="post_origin" name="post[origin]"><optgroup label="&lt;Africa&gt;"><option value="&lt;sa&gt;">&lt;South Africa&gt;</option>\n<option value="so">Somalia</option></optgroup><optgroup label="Europe"><option value="dk" selected="selected">Denmark</option>\n<option value="ie">Ireland</option></optgroup></select>},
-      grouped_collection_select("post", "origin", dummy_continents, :countries, :continent_name, :country_id, :country_name, :selected => 'dk')
-    )
-  end
-
-  def test_grouped_collection_select_with_disabled_value
-    @post = Post.new
-
-    assert_dom_equal(
-      %Q{<select id="post_origin" name="post[origin]"><optgroup label="&lt;Africa&gt;"><option value="&lt;sa&gt;">&lt;South Africa&gt;</option>\n<option value="so">Somalia</option></optgroup><optgroup label="Europe"><option disabled="disabled" value="dk">Denmark</option>\n<option value="ie">Ireland</option></optgroup></select>},
-      grouped_collection_select("post", "origin", dummy_continents, :countries, :continent_name, :country_id, :country_name, :disabled => 'dk')
-    )
-  end
-
-  def test_grouped_collection_select_under_fields_for
-    @post = Post.new
-    @post.origin = 'dk'
-
-    output_buffer = fields_for :post, @post do |f|
-      concat f.grouped_collection_select("origin", dummy_continents, :countries, :continent_name, :country_id, :country_name)
-    end
-
-    assert_dom_equal(
-      %Q{<select id="post_origin" name="post[origin]"><optgroup label="&lt;Africa&gt;"><option value="&lt;sa&gt;">&lt;South Africa&gt;</option>\n<option value="so">Somalia</option></optgroup><optgroup label="Europe"><option value="dk" selected="selected">Denmark</option>\n<option value="ie">Ireland</option></optgroup></select>},
-      output_buffer
-    )
-  end
-
-  private
-
-  def dummy_posts
-    [ Post.new("<Abe> went home", "<Abe>", "To a little house", "shh!"),
-      Post.new("Babe went home", "Babe", "To a little house", "shh!"),
-      Post.new("Cabe went home", "Cabe", "To a little house", "shh!") ]
-  end
-
-  def dummy_continents
-    [ Continent.new("<Africa>", [Country.new("<sa>", "<South Africa>"), Country.new("so", "Somalia")]),
-      Continent.new("Europe", [Country.new("dk", "Denmark"), Country.new("ie", "Ireland")]) ]
-  end
-end
diff --git a/actionpack/test/template/form_tag_helper_test.rb b/actionpack/test/template/form_tag_helper_test.rb
deleted file mode 100644
index 6c6a142397..0000000000
--- a/actionpack/test/template/form_tag_helper_test.rb
+++ /dev/null
@@ -1,642 +0,0 @@
-require 'abstract_unit'
-
-class FormTagHelperTest < ActionView::TestCase
-  include RenderERBUtils
-
-  tests ActionView::Helpers::FormTagHelper
-
-  def setup
-    super
-    @controller = BasicController.new
-  end
-
-  def hidden_fields(options = {})
-    method = options[:method]
-
-    txt =  %{<div style="margin:0;padding:0;display:inline">}
-    txt << %{<input name="utf8" type="hidden" value="&#x2713;" />}
-    if method && !%w(get post).include?(method.to_s)
-      txt << %{<input name="_method" type="hidden" value="#{method}" />}
-    end
-    txt << %{</div>}
-  end
-
-  def form_text(action = "http://www.example.com", options = {})
-    remote, enctype, html_class, id, method = options.values_at(:remote, :enctype, :html_class, :id, :method)
-
-    method = method.to_s == "get" ? "get" : "post"
-
-    txt =  %{<form accept-charset="UTF-8" action="#{action}"}
-    txt << %{ enctype="multipart/form-data"} if enctype
-    txt << %{ data-remote="true"} if remote
-    txt << %{ class="#{html_class}"} if html_class
-    txt << %{ id="#{id}"} if id
-    txt << %{ method="#{method}">}
-  end
-
-  def whole_form(action = "http://www.example.com", options = {})
-    out = form_text(action, options) + hidden_fields(options)
-
-    if block_given?
-      out << yield << "</form>"
-    end
-
-    out
-  end
-
-  def url_for(options)
-    if options.is_a?(Hash)
-      "http://www.example.com"
-    else
-      super
-    end
-  end
-
-  VALID_HTML_ID = /^[A-Za-z][-_:.A-Za-z0-9]*$/ # see http://www.w3.org/TR/html4/types.html#type-name
-
-  def test_check_box_tag
-    actual = check_box_tag "admin"
-    expected = %(<input id="admin" name="admin" type="checkbox" value="1" />)
-    assert_dom_equal expected, actual
-  end
-
-  def test_check_box_tag_id_sanitized
-    label_elem = root_elem(check_box_tag("project[2][admin]"))
-    assert_match VALID_HTML_ID, label_elem['id']
-  end
-
-  def test_form_tag
-    actual = form_tag
-    expected = whole_form
-    assert_dom_equal expected, actual
-  end
-
-  def test_form_tag_multipart
-    actual = form_tag({}, { 'multipart' => true })
-    expected = whole_form("http://www.example.com", :enctype => true)
-    assert_dom_equal expected, actual
-  end
-
-  def test_form_tag_with_method_patch
-    actual = form_tag({}, { :method => :patch })
-    expected = whole_form("http://www.example.com", :method => :patch)
-    assert_dom_equal expected, actual
-  end
-
-  def test_form_tag_with_method_put
-    actual = form_tag({}, { :method => :put })
-    expected = whole_form("http://www.example.com", :method => :put)
-    assert_dom_equal expected, actual
-  end
-
-  def test_form_tag_with_method_delete
-    actual = form_tag({}, { :method => :delete })
-
-    expected = whole_form("http://www.example.com", :method => :delete)
-    assert_dom_equal expected, actual
-  end
-
-  def test_form_tag_with_remote
-    actual = form_tag({}, :remote => true)
-
-    expected = whole_form("http://www.example.com", :remote => true)
-    assert_dom_equal expected, actual
-  end
-
-  def test_form_tag_with_remote_false
-    actual = form_tag({}, :remote => false)
-
-    expected = whole_form
-    assert_dom_equal expected, actual
-  end
-
-  def test_form_tag_with_block_in_erb
-    output_buffer = render_erb("<%= form_tag('http://www.example.com') do %>Hello world!<% end %>")
-
-    expected = whole_form { "Hello world!" }
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_form_tag_with_block_and_method_in_erb
-    output_buffer = render_erb("<%= form_tag('http://www.example.com', :method => :put) do %>Hello world!<% end %>")
-
-    expected = whole_form("http://www.example.com", :method => "put") do
-      "Hello world!"
-    end
-
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_hidden_field_tag
-    actual = hidden_field_tag "id", 3
-    expected = %(<input id="id" name="id" type="hidden" value="3" />)
-    assert_dom_equal expected, actual
-  end
-
-  def test_hidden_field_tag_id_sanitized
-    input_elem = root_elem(hidden_field_tag("item[][title]"))
-    assert_match VALID_HTML_ID, input_elem['id']
-  end
-
-  def test_file_field_tag
-    assert_dom_equal "<input name=\"picsplz\" type=\"file\" id=\"picsplz\" />", file_field_tag("picsplz")
-  end
-
-  def test_file_field_tag_with_options
-    assert_dom_equal "<input name=\"picsplz\" type=\"file\" id=\"picsplz\" class=\"pix\"/>", file_field_tag("picsplz", :class => "pix")
-  end
-
-  def test_password_field_tag
-    actual = password_field_tag
-    expected = %(<input id="password" name="password" type="password" />)
-    assert_dom_equal expected, actual
-  end
-
-  def test_radio_button_tag
-    actual = radio_button_tag "people", "david"
-    expected = %(<input id="people_david" name="people" type="radio" value="david" />)
-    assert_dom_equal expected, actual
-
-    actual = radio_button_tag("num_people", 5)
-    expected = %(<input id="num_people_5" name="num_people" type="radio" value="5" />)
-    assert_dom_equal expected, actual
-
-    actual = radio_button_tag("gender", "m") + radio_button_tag("gender", "f")
-    expected = %(<input id="gender_m" name="gender" type="radio" value="m" /><input id="gender_f" name="gender" type="radio" value="f" />)
-    assert_dom_equal expected, actual
-
-    actual = radio_button_tag("opinion", "-1") + radio_button_tag("opinion", "1")
-    expected = %(<input id="opinion_-1" name="opinion" type="radio" value="-1" /><input id="opinion_1" name="opinion" type="radio" value="1" />)
-    assert_dom_equal expected, actual
-
-    actual = radio_button_tag("person[gender]", "m")
-    expected = %(<input id="person_gender_m" name="person[gender]" type="radio" value="m" />)
-    assert_dom_equal expected, actual
-
-    actual = radio_button_tag('ctrlname', 'apache2.2')
-    expected = %(<input id="ctrlname_apache2.2" name="ctrlname" type="radio" value="apache2.2" />)
-    assert_dom_equal expected, actual
-  end
-
-  def test_select_tag
-    actual = select_tag "people", "<option>david</option>".html_safe
-    expected = %(<select id="people" name="people"><option>david</option></select>)
-    assert_dom_equal expected, actual
-  end
-
-  def test_select_tag_with_multiple
-    actual = select_tag "colors", "<option>Red</option><option>Blue</option><option>Green</option>".html_safe, :multiple => :true
-    expected = %(<select id="colors" multiple="multiple" name="colors"><option>Red</option><option>Blue</option><option>Green</option></select>)
-    assert_dom_equal expected, actual
-  end
-
-  def test_select_tag_disabled
-    actual = select_tag "places", "<option>Home</option><option>Work</option><option>Pub</option>".html_safe, :disabled => :true
-    expected = %(<select id="places" disabled="disabled" name="places"><option>Home</option><option>Work</option><option>Pub</option></select>)
-    assert_dom_equal expected, actual
-  end
-
-  def test_select_tag_id_sanitized
-    input_elem = root_elem(select_tag("project[1]people", "<option>david</option>"))
-    assert_match VALID_HTML_ID, input_elem['id']
-  end
-
-  def test_select_tag_with_include_blank
-    actual = select_tag "places", "<option>Home</option><option>Work</option><option>Pub</option>".html_safe, :include_blank => true
-    expected = %(<select id="places" name="places"><option value=""></option><option>Home</option><option>Work</option><option>Pub</option></select>)
-    assert_dom_equal expected, actual
-  end
-
-  def test_select_tag_with_prompt
-    actual = select_tag "places", "<option>Home</option><option>Work</option><option>Pub</option>".html_safe, :prompt => "string"
-    expected = %(<select id="places" name="places"><option value="">string</option><option>Home</option><option>Work</option><option>Pub</option></select>)
-    assert_dom_equal expected, actual
-  end
-
-  def test_select_tag_escapes_prompt
-    actual = select_tag "places", "<option>Home</option><option>Work</option><option>Pub</option>".html_safe, :prompt => "<script>alert(1337)</script>"
-    expected = %(<select id="places" name="places"><option value="">&lt;script&gt;alert(1337)&lt;/script&gt;</option><option>Home</option><option>Work</option><option>Pub</option></select>)
-    assert_dom_equal expected, actual
-  end
-
-  def test_select_tag_with_prompt_and_include_blank
-    actual = select_tag "places", "<option>Home</option><option>Work</option><option>Pub</option>".html_safe, :prompt => "string", :include_blank => true
-    expected = %(<select name="places" id="places"><option value="">string</option><option value=""></option><option>Home</option><option>Work</option><option>Pub</option></select>)
-    assert_dom_equal expected, actual
-  end
-
-  def test_select_tag_with_nil_option_tags_and_include_blank
-    actual = select_tag "places", nil, :include_blank => true
-    expected = %(<select id="places" name="places"><option value=""></option></select>)
-    assert_dom_equal expected, actual
-  end
-
-  def test_select_tag_with_nil_option_tags_and_prompt
-    actual = select_tag "places", nil, :prompt => "string"
-    expected = %(<select id="places" name="places"><option value="">string</option></select>)
-    assert_dom_equal expected, actual
-  end
-
-  def test_text_area_tag_size_string
-    actual = text_area_tag "body", "hello world", "size" => "20x40"
-    expected = %(<textarea cols="20" id="body" name="body" rows="40">\nhello world</textarea>)
-    assert_dom_equal expected, actual
-  end
-
-  def test_text_area_tag_size_symbol
-    actual = text_area_tag "body", "hello world", :size => "20x40"
-    expected = %(<textarea cols="20" id="body" name="body" rows="40">\nhello world</textarea>)
-    assert_dom_equal expected, actual
-  end
-
-  def test_text_area_tag_should_disregard_size_if_its_given_as_an_integer
-    actual = text_area_tag "body", "hello world", :size => 20
-    expected = %(<textarea id="body" name="body">\nhello world</textarea>)
-    assert_dom_equal expected, actual
-  end
-
-  def test_text_area_tag_id_sanitized
-    input_elem = root_elem(text_area_tag("item[][description]"))
-    assert_match VALID_HTML_ID, input_elem['id']
-  end
-
-  def test_text_area_tag_escape_content
-    actual = text_area_tag "body", "<b>hello world</b>", :size => "20x40"
-    expected = %(<textarea cols="20" id="body" name="body" rows="40">\n&lt;b&gt;hello world&lt;/b&gt;</textarea>)
-    assert_dom_equal expected, actual
-  end
-
-  def test_text_area_tag_unescaped_content
-    actual = text_area_tag "body", "<b>hello world</b>", :size => "20x40", :escape => false
-    expected = %(<textarea cols="20" id="body" name="body" rows="40">\n<b>hello world</b></textarea>)
-    assert_dom_equal expected, actual
-  end
-
-  def test_text_area_tag_unescaped_nil_content
-    actual = text_area_tag "body", nil, :escape => false
-    expected = %(<textarea id="body" name="body">\n</textarea>)
-    assert_dom_equal expected, actual
-  end
-
-  def test_text_field_tag
-    actual = text_field_tag "title", "Hello!"
-    expected = %(<input id="title" name="title" type="text" value="Hello!" />)
-    assert_dom_equal expected, actual
-  end
-
-  def test_text_field_tag_class_string
-    actual = text_field_tag "title", "Hello!", "class" => "admin"
-    expected = %(<input class="admin" id="title" name="title" type="text" value="Hello!" />)
-    assert_dom_equal expected, actual
-  end
-
-  def test_text_field_tag_size_symbol
-    actual = text_field_tag "title", "Hello!", :size => 75
-    expected = %(<input id="title" name="title" size="75" type="text" value="Hello!" />)
-    assert_dom_equal expected, actual
-  end
-
-  def test_text_field_tag_size_string
-    actual = text_field_tag "title", "Hello!", "size" => "75"
-    expected = %(<input id="title" name="title" size="75" type="text" value="Hello!" />)
-    assert_dom_equal expected, actual
-  end
-
-  def test_text_field_tag_maxlength_symbol
-    actual = text_field_tag "title", "Hello!", :maxlength => 75
-    expected = %(<input id="title" name="title" maxlength="75" type="text" value="Hello!" />)
-    assert_dom_equal expected, actual
-  end
-
-  def test_text_field_tag_maxlength_string
-    actual = text_field_tag "title", "Hello!", "maxlength" => "75"
-    expected = %(<input id="title" name="title" maxlength="75" type="text" value="Hello!" />)
-    assert_dom_equal expected, actual
-  end
-
-  def test_text_field_disabled
-    actual = text_field_tag "title", "Hello!", :disabled => :true
-    expected = %(<input id="title" name="title" disabled="disabled" type="text" value="Hello!" />)
-    assert_dom_equal expected, actual
-  end
-
-  def test_text_field_tag_with_multiple_options
-    actual = text_field_tag "title", "Hello!", :size => 70, :maxlength => 80
-    expected = %(<input id="title" name="title" size="70" maxlength="80" type="text" value="Hello!" />)
-    assert_dom_equal expected, actual
-  end
-
-  def test_text_field_tag_id_sanitized
-    input_elem = root_elem(text_field_tag("item[][title]"))
-    assert_match VALID_HTML_ID, input_elem['id']
-  end
-
-  def test_label_tag_without_text
-    actual = label_tag "title"
-    expected = %(<label for="title">Title</label>)
-    assert_dom_equal expected, actual
-  end
-
-  def test_label_tag_with_symbol
-    actual = label_tag :title
-    expected = %(<label for="title">Title</label>)
-    assert_dom_equal expected, actual
-  end
-
-  def test_label_tag_with_text
-    actual = label_tag "title", "My Title"
-    expected = %(<label for="title">My Title</label>)
-    assert_dom_equal expected, actual
-  end
-
-  def test_label_tag_class_string
-    actual = label_tag "title", "My Title", "class" => "small_label"
-    expected = %(<label for="title" class="small_label">My Title</label>)
-    assert_dom_equal expected, actual
-  end
-
-  def test_label_tag_id_sanitized
-    label_elem = root_elem(label_tag("item[title]"))
-    assert_match VALID_HTML_ID, label_elem['for']
-  end
-
-  def test_label_tag_with_block
-    assert_dom_equal('<label>Blocked</label>', label_tag { "Blocked" })
-  end
-
-  def test_label_tag_with_block_and_argument
-    output = label_tag("clock") { "Grandfather" }
-    assert_dom_equal('<label for="clock">Grandfather</label>', output)
-  end
-
-  def test_label_tag_with_block_and_argument_and_options
-    output = label_tag("clock", :id => "label_clock") { "Grandfather" }
-    assert_dom_equal('<label for="clock" id="label_clock">Grandfather</label>', output)
-  end
-
-  def test_boolean_options
-    assert_dom_equal %(<input checked="checked" disabled="disabled" id="admin" name="admin" readonly="readonly" type="checkbox" value="1" />), check_box_tag("admin", 1, true, 'disabled' => true, :readonly => "yes")
-    assert_dom_equal %(<input checked="checked" id="admin" name="admin" type="checkbox" value="1" />), check_box_tag("admin", 1, true, :disabled => false, :readonly => nil)
-    assert_dom_equal %(<input type="checkbox" />), tag(:input, :type => "checkbox", :checked => false)
-    assert_dom_equal %(<select id="people" multiple="multiple" name="people[]"><option>david</option></select>), select_tag("people", "<option>david</option>".html_safe, :multiple => true)
-    assert_dom_equal %(<select id="people_" multiple="multiple" name="people[]"><option>david</option></select>), select_tag("people[]", "<option>david</option>".html_safe, :multiple => true)
-    assert_dom_equal %(<select id="people" name="people"><option>david</option></select>), select_tag("people", "<option>david</option>".html_safe, :multiple => nil)
-  end
-
-  def test_stringify_symbol_keys
-    actual = text_field_tag "title", "Hello!", :id => "admin"
-    expected = %(<input id="admin" name="title" type="text" value="Hello!" />)
-    assert_dom_equal expected, actual
-  end
-
-  def test_submit_tag
-    assert_dom_equal(
-      %(<input name='commit' data-disable-with="Saving..." onclick="alert(&#39;hello!&#39;)" type="submit" value="Save" />),
-      submit_tag("Save", :onclick => "alert('hello!')", :data => { :disable_with => "Saving..." })
-    )
-  end
-
-  def test_submit_tag_with_no_onclick_options
-    assert_dom_equal(
-      %(<input name='commit' data-disable-with="Saving..." type="submit" value="Save" />),
-      submit_tag("Save", :data => { :disable_with => "Saving..." })
-    )
-  end
-
-  def test_submit_tag_with_confirmation
-    assert_dom_equal(
-      %(<input name='commit' type='submit' value='Save' data-confirm="Are you sure?" />),
-      submit_tag("Save", :data => { :confirm => "Are you sure?" })
-    )
-  end
-
-  def test_submit_tag_with_deprecated_confirmation
-    assert_deprecated ":confirm option is deprecated and will be removed from Rails 4.1. Use 'data: { confirm: \'Text\' }' instead" do
-      assert_dom_equal(
-        %(<input name='commit' type='submit' value='Save' data-confirm="Are you sure?" />),
-        submit_tag("Save", :confirm => "Are you sure?")
-      )
-    end
-  end
-
-  def test_button_tag
-    assert_dom_equal(
-      %(<button name="button" type="submit">Button</button>),
-      button_tag
-    )
-  end
-
-  def test_button_tag_with_submit_type
-    assert_dom_equal(
-      %(<button name="button" type="submit">Save</button>),
-      button_tag("Save", :type => "submit")
-    )
-  end
-
-  def test_button_tag_with_button_type
-    assert_dom_equal(
-      %(<button name="button" type="button">Button</button>),
-      button_tag("Button", :type => "button")
-    )
-  end
-
-  def test_button_tag_with_reset_type
-    assert_dom_equal(
-      %(<button name="button" type="reset">Reset</button>),
-      button_tag("Reset", :type => "reset")
-    )
-  end
-
-  def test_button_tag_with_disabled_option
-    assert_dom_equal(
-      %(<button name="button" type="reset" disabled="disabled">Reset</button>),
-      button_tag("Reset", :type => "reset", :disabled => true)
-    )
-  end
-
-  def test_button_tag_escape_content
-    assert_dom_equal(
-      %(<button name="button" type="reset" disabled="disabled">&lt;b&gt;Reset&lt;/b&gt;</button>),
-      button_tag("<b>Reset</b>", :type => "reset", :disabled => true)
-    )
-  end
-
-  def test_button_tag_with_block
-    assert_dom_equal('<button name="button" type="submit">Content</button>', button_tag { 'Content' })
-  end
-
-  def test_button_tag_with_block_and_options
-    output = button_tag(:name => 'temptation', :type => 'button') { content_tag(:strong, 'Do not press me') }
-    assert_dom_equal('<button name="temptation" type="button"><strong>Do not press me</strong></button>', output)
-  end
-
-  def test_button_tag_with_confirmation
-    assert_dom_equal(
-      %(<button name="button" type="submit" data-confirm="Are you sure?">Save</button>),
-      button_tag("Save", :type => "submit", :data => { :confirm => "Are you sure?" })
-    )
-  end
-
-  def test_button_tag_with_deprecated_confirmation
-    assert_deprecated ":confirm option is deprecated and will be removed from Rails 4.1. Use 'data: { confirm: \'Text\' }' instead" do
-      assert_dom_equal(
-        %(<button name="button" type="submit" data-confirm="Are you sure?">Save</button>),
-        button_tag("Save", :type => "submit", :confirm => "Are you sure?")
-      )
-    end
-  end
-
-  def test_image_submit_tag_with_confirmation
-    assert_dom_equal(
-      %(<input alt="Save" type="image" src="/images/save.gif" data-confirm="Are you sure?" />),
-      image_submit_tag("save.gif", :data => { :confirm => "Are you sure?" })
-    )
-  end
-
-  def test_image_submit_tag_with_deprecated_confirmation
-    assert_deprecated ":confirm option is deprecated and will be removed from Rails 4.1. Use 'data: { confirm: \'Text\' }' instead" do
-      assert_dom_equal(
-        %(<input alt="Save" type="image" src="/images/save.gif" data-confirm="Are you sure?" />),
-        image_submit_tag("save.gif", :confirm => "Are you sure?")
-      )
-    end
-  end
-
-
-  def test_color_field_tag
-    expected = %{<input id="car" name="car" type="color" />}
-    assert_dom_equal(expected, color_field_tag("car"))
-  end
-
-  def test_search_field_tag
-    expected = %{<input id="query" name="query" type="search" />}
-    assert_dom_equal(expected, search_field_tag("query"))
-  end
-
-  def test_telephone_field_tag
-    expected = %{<input id="cell" name="cell" type="tel" />}
-    assert_dom_equal(expected, telephone_field_tag("cell"))
-  end
-
-  def test_date_field_tag
-    expected = %{<input id="cell" name="cell" type="date" />}
-    assert_dom_equal(expected, date_field_tag("cell"))
-  end
-
-  def test_time_field_tag
-    expected = %{<input id="cell" name="cell" type="time" />}
-    assert_dom_equal(expected, time_field_tag("cell"))
-  end
-
-  def test_datetime_field_tag
-    expected = %{<input id="appointment" name="appointment" type="datetime" />}
-    assert_dom_equal(expected, datetime_field_tag("appointment"))
-  end
-
-  def test_datetime_local_field_tag
-    expected = %{<input id="appointment" name="appointment" type="datetime-local" />}
-    assert_dom_equal(expected, datetime_local_field_tag("appointment"))
-  end
-
-  def test_month_field_tag
-    expected = %{<input id="birthday" name="birthday" type="month" />}
-    assert_dom_equal(expected, month_field_tag("birthday"))
-  end
-
-  def test_week_field_tag
-    expected = %{<input id="birthday" name="birthday" type="week" />}
-    assert_dom_equal(expected, week_field_tag("birthday"))
-  end
-
-  def test_url_field_tag
-    expected = %{<input id="homepage" name="homepage" type="url" />}
-    assert_dom_equal(expected, url_field_tag("homepage"))
-  end
-
-  def test_email_field_tag
-    expected = %{<input id="address" name="address" type="email" />}
-    assert_dom_equal(expected, email_field_tag("address"))
-  end
-
-  def test_number_field_tag
-    expected = %{<input name="quantity" max="9" id="quantity" type="number" min="1" />}
-    assert_dom_equal(expected, number_field_tag("quantity", nil, :in => 1...10))
-  end
-
-  def test_range_input_tag
-    expected = %{<input name="volume" step="0.1" max="11" id="volume" type="range" min="0" />}
-    assert_dom_equal(expected, range_field_tag("volume", nil, :in => 0..11, :step => 0.1))
-  end
-
-  def test_field_set_tag_in_erb
-    output_buffer = render_erb("<%= field_set_tag('Your details') do %>Hello world!<% end %>")
-
-    expected = %(<fieldset><legend>Your details</legend>Hello world!</fieldset>)
-    assert_dom_equal expected, output_buffer
-
-    output_buffer = render_erb("<%= field_set_tag do %>Hello world!<% end %>")
-
-    expected = %(<fieldset>Hello world!</fieldset>)
-    assert_dom_equal expected, output_buffer
-
-    output_buffer = render_erb("<%= field_set_tag('') do %>Hello world!<% end %>")
-
-    expected = %(<fieldset>Hello world!</fieldset>)
-    assert_dom_equal expected, output_buffer
-
-    output_buffer = render_erb("<%= field_set_tag('', :class => 'format') do %>Hello world!<% end %>")
-
-    expected = %(<fieldset class="format">Hello world!</fieldset>)
-    assert_dom_equal expected, output_buffer
-
-    output_buffer = render_erb("<%= field_set_tag %>")
-
-    expected = %(<fieldset></fieldset>)
-    assert_dom_equal expected, output_buffer
-
-    output_buffer = render_erb("<%= field_set_tag('You legend!') %>")
-
-    expected = %(<fieldset><legend>You legend!</legend></fieldset>)
-    assert_dom_equal expected, output_buffer
-  end
-
-  def test_text_area_tag_options_symbolize_keys_side_effects
-    options = { :option => "random_option" }
-    text_area_tag "body", "hello world", options
-    assert_equal options, { :option => "random_option" }
-  end
-
-  def test_submit_tag_options_symbolize_keys_side_effects
-    options = { :option => "random_option" }
-    submit_tag "submit value", options
-    assert_equal options, { :option => "random_option" }
-  end
-
-  def test_button_tag_options_symbolize_keys_side_effects
-    options = { :option => "random_option" }
-    button_tag "button value", options
-    assert_equal options, { :option => "random_option" }
-  end
-
-  def test_image_submit_tag_options_symbolize_keys_side_effects
-    options = { :option => "random_option" }
-    image_submit_tag "submit source", options
-    assert_equal options, { :option => "random_option" }
-  end
-
-  def test_image_label_tag_options_symbolize_keys_side_effects
-    options = { :option => "random_option" }
-    label_tag "submit source", "title", options
-    assert_equal options, { :option => "random_option" }
-  end
-
-  def protect_against_forgery?
-    false
-  end
-
-  private
-
-  def root_elem(rendered_content)
-    HTML::Document.new(rendered_content).root.children[0]
-  end
-end
diff --git a/actionpack/test/template/html-scanner/cdata_node_test.rb b/actionpack/test/template/html-scanner/cdata_node_test.rb
deleted file mode 100644
index 9b58174641..0000000000
--- a/actionpack/test/template/html-scanner/cdata_node_test.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-require 'abstract_unit'
-
-class CDATANodeTest < ActiveSupport::TestCase
-  def setup
-    @node = HTML::CDATA.new(nil, 0, 0, "<p>howdy</p>")
-  end
-
-  def test_to_s
-    assert_equal "<![CDATA[<p>howdy</p>]]>", @node.to_s
-  end
-
-  def test_content
-    assert_equal "<p>howdy</p>", @node.content
-  end
-end
diff --git a/actionpack/test/template/html-scanner/document_test.rb b/actionpack/test/template/html-scanner/document_test.rb
deleted file mode 100644
index 17f045d549..0000000000
--- a/actionpack/test/template/html-scanner/document_test.rb
+++ /dev/null
@@ -1,148 +0,0 @@
-require 'abstract_unit'
-
-class DocumentTest < ActiveSupport::TestCase
-  def test_handle_doctype
-    doc = nil
-    assert_nothing_raised do
-      doc = HTML::Document.new <<-HTML.strip
-        <!DOCTYPE "blah" "blah" "blah">
-        <html>
-        </html>
-      HTML
-    end
-    assert_equal 3, doc.root.children.length
-    assert_equal %{<!DOCTYPE "blah" "blah" "blah">}, doc.root.children[0].content
-    assert_match %r{\s+}m, doc.root.children[1].content
-    assert_equal "html", doc.root.children[2].name
-  end
-
-  def test_find_img
-    doc = HTML::Document.new <<-HTML.strip
-      <html>
-        <body>
-          <p><img src="hello.gif"></p>
-        </body>
-      </html>
-    HTML
-    assert doc.find(:tag=>"img", :attributes=>{"src"=>"hello.gif"})
-  end
-
-  def test_find_all
-    doc = HTML::Document.new <<-HTML.strip
-      <html>
-        <body>
-          <p class="test"><img src="hello.gif"></p>
-          <div class="foo">
-            <p class="test">something</p>
-            <p>here is <em class="test">more</em></p>
-          </div>
-        </body>
-      </html>
-    HTML
-    all = doc.find_all :attributes => { :class => "test" }
-    assert_equal 3, all.length
-    assert_equal [ "p", "p", "em" ], all.map { |n| n.name }
-  end
-
-  def test_find_with_text
-    doc = HTML::Document.new <<-HTML.strip
-      <html>
-        <body>
-          <p>Some text</p>
-        </body>
-      </html>
-    HTML
-    assert doc.find(:content => "Some text")
-    assert doc.find(:tag => "p", :child => { :content => "Some text" })
-    assert doc.find(:tag => "p", :child => "Some text")
-    assert doc.find(:tag => "p", :content => "Some text")
-  end
-
-  def test_parse_xml
-    assert_nothing_raised { HTML::Document.new("<tags><tag/></tags>", true, true) }
-    assert_nothing_raised { HTML::Document.new("<outer><link>something</link></outer>", true, true) }
-  end
-
-  def test_parse_document
-    doc = HTML::Document.new(<<-HTML)
-      <div>
-        <h2>blah</h2>
-        <table>
-        </table>
-      </div>
-    HTML
-    assert_not_nil doc.find(:tag => "div", :children => { :count => 1, :only => { :tag => "table" } })
-  end
-
-  def test_tag_nesting_nothing_to_s
-    doc = HTML::Document.new("<tag></tag>")
-    assert_equal "<tag></tag>", doc.root.to_s
-  end
-
-  def test_tag_nesting_space_to_s
-    doc = HTML::Document.new("<tag> </tag>")
-    assert_equal "<tag> </tag>", doc.root.to_s
-  end
-
-  def test_tag_nesting_text_to_s
-    doc = HTML::Document.new("<tag>text</tag>")
-    assert_equal "<tag>text</tag>", doc.root.to_s
-  end
-
-  def test_tag_nesting_tag_to_s
-    doc = HTML::Document.new("<tag><nested /></tag>")
-    assert_equal "<tag><nested /></tag>", doc.root.to_s
-  end
-
-  def test_parse_cdata
-    doc = HTML::Document.new(<<-HTML)
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
-  <head>
-    <title><![CDATA[<br>]]></title>
-   </head>
-  <body>
-    <p>this document has &lt;br&gt; for a title</p>
-  </body>
-</html>
-HTML
-
-    assert_nil doc.find(:tag => "title", :descendant => { :tag => "br" })
-    assert doc.find(:tag => "title", :child => "<br>")
-  end
-
-  def test_find_empty_tag
-    doc = HTML::Document.new("<div id='map'></div>")
-    assert_nil doc.find(:tag => "div", :attributes => { :id => "map" }, :content => /./)
-    assert doc.find(:tag => "div", :attributes => { :id => "map" }, :content => /\A\Z/)
-    assert doc.find(:tag => "div", :attributes => { :id => "map" }, :content => /^$/)
-    assert doc.find(:tag => "div", :attributes => { :id => "map" }, :content => "")
-    assert doc.find(:tag => "div", :attributes => { :id => "map" }, :content => nil)
-  end
-
-  def test_parse_invalid_document
-    assert_nothing_raised do
-      HTML::Document.new("<html>
-        <table>
-          <tr>
-            <td style=\"color: #FFFFFF; height: 17px; onclick=\"window.location.href='http://www.rmeinc.com/about_rme.aspx'\" style=\"cursor:pointer; height: 17px;\"; nowrap onclick=\"window.location.href='http://www.rmeinc.com/about_rme.aspx'\" onmouseout=\"this.bgColor='#0066cc'; this.style.color='#FFFFFF'\" onmouseover=\"this.bgColor='#ffffff'; this.style.color='#0033cc'\">About Us</td>
-          </tr>
-        </table>
-      </html>")
-    end
-  end
-
-  def test_invalid_document_raises_exception_when_strict
-    assert_raise RuntimeError do
-      HTML::Document.new("<html>
-        <table>
-          <tr>
-            <td style=\"color: #FFFFFF; height: 17px; onclick=\"window.location.href='http://www.rmeinc.com/about_rme.aspx'\" style=\"cursor:pointer; height: 17px;\"; nowrap onclick=\"window.location.href='http://www.rmeinc.com/about_rme.aspx'\" onmouseout=\"this.bgColor='#0066cc'; this.style.color='#FFFFFF'\" onmouseover=\"this.bgColor='#ffffff'; this.style.color='#0033cc'\">About Us</td>
-          </tr>
-        </table>
-      </html>", true)
-    end
-  end
-
-end
diff --git a/actionpack/test/template/html-scanner/node_test.rb b/actionpack/test/template/html-scanner/node_test.rb
deleted file mode 100644
index 5b5d092036..0000000000
--- a/actionpack/test/template/html-scanner/node_test.rb
+++ /dev/null
@@ -1,89 +0,0 @@
-require 'abstract_unit'
-
-class NodeTest < ActiveSupport::TestCase
-
-  class MockNode
-    def initialize(matched, value)
-      @matched = matched
-      @value = value
-    end
-
-    def find(conditions)
-      @matched && self
-    end
-
-    def to_s
-      @value.to_s
-    end
-  end
-
-  def setup
-    @node = HTML::Node.new("parent")
-    @node.children.concat [MockNode.new(false,1), MockNode.new(true,"two"), MockNode.new(false,:three)]
-  end
-
-  def test_match
-    assert !@node.match("foo")
-  end
-
-  def test_tag
-    assert !@node.tag?
-  end
-
-  def test_to_s
-    assert_equal "1twothree", @node.to_s
-  end
-
-  def test_find
-    assert_equal "two", @node.find('blah').to_s
-  end
-
-  def test_parse_strict
-    s = "<b foo='hello'' bar='baz'>"
-    assert_raise(RuntimeError) { HTML::Node.parse(nil,0,0,s) }
-  end
-
-  def test_parse_relaxed
-    s = "<b foo='hello'' bar='baz'>"
-    node = nil
-    assert_nothing_raised { node = HTML::Node.parse(nil,0,0,s,false) }
-    assert node.attributes.has_key?("foo")
-    assert !node.attributes.has_key?("bar")
-  end
-
-  def test_to_s_with_boolean_attrs
-    s = "<b foo bar>"
-    node = HTML::Node.parse(nil,0,0,s)
-    assert node.attributes.has_key?("foo")
-    assert node.attributes.has_key?("bar")
-    assert "<b foo bar>", node.to_s
-  end
-
-  def test_parse_with_unclosed_tag
-    s = "<span onmouseover='bang'"
-    node = nil
-    assert_nothing_raised { node = HTML::Node.parse(nil,0,0,s,false) }
-    assert node.attributes.has_key?("onmouseover")
-  end
-
-  def test_parse_with_valid_cdata_section
-    s = "<![CDATA[<span>contents</span>]]>"
-    node = nil
-    assert_nothing_raised { node = HTML::Node.parse(nil,0,0,s,false) }
-    assert_kind_of HTML::CDATA, node
-    assert_equal '<span>contents</span>', node.content
-  end
-
-  def test_parse_strict_with_unterminated_cdata_section
-    s = "<![CDATA[neverending..."
-    assert_raise(RuntimeError) { HTML::Node.parse(nil,0,0,s) }
-  end
-
-  def test_parse_relaxed_with_unterminated_cdata_section
-    s = "<![CDATA[neverending..."
-    node = nil
-    assert_nothing_raised { node = HTML::Node.parse(nil,0,0,s,false) }
-    assert_kind_of HTML::CDATA, node
-    assert_equal 'neverending...', node.content
-  end
-end
diff --git a/actionpack/test/template/html-scanner/sanitizer_test.rb b/actionpack/test/template/html-scanner/sanitizer_test.rb
deleted file mode 100644
index b1c1b83807..0000000000
--- a/actionpack/test/template/html-scanner/sanitizer_test.rb
+++ /dev/null
@@ -1,330 +0,0 @@
-require 'abstract_unit'
-
-class SanitizerTest < ActionController::TestCase
-  def setup
-    @sanitizer = nil # used by assert_sanitizer
-  end
-
-  def test_strip_tags_with_quote
-    sanitizer = HTML::FullSanitizer.new
-    string    = '<" <img src="trollface.gif" onload="alert(1)"> hi'
-
-    assert_equal ' hi', sanitizer.sanitize(string)
-  end
-
-  def test_strip_tags
-    sanitizer = HTML::FullSanitizer.new
-    assert_equal("<<<bad html", sanitizer.sanitize("<<<bad html"))
-    assert_equal("<<", sanitizer.sanitize("<<<bad html>"))
-    assert_equal("Dont touch me", sanitizer.sanitize("Dont touch me"))
-    assert_equal("This is a test.", sanitizer.sanitize("<p>This <u>is<u> a <a href='test.html'><strong>test</strong></a>.</p>"))
-    assert_equal("Weirdos", sanitizer.sanitize("Wei<<a>a onclick='alert(document.cookie);'</a>/>rdos"))
-    assert_equal("This is a test.", sanitizer.sanitize("This is a test."))
-    assert_equal(
-    %{This is a test.\n\n\nIt no longer contains any HTML.\n}, sanitizer.sanitize(
-    %{<title>This is <b>a <a href="" target="_blank">test</a></b>.</title>\n\n<!-- it has a comment -->\n\n<p>It no <b>longer <strong>contains <em>any <strike>HTML</strike></em>.</strong></b></p>\n}))
-    assert_equal "This has a  here.", sanitizer.sanitize("This has a <!-- comment --> here.")
-    assert_equal "This has a  here.", sanitizer.sanitize("This has a <![CDATA[<section>]]> here.")
-    assert_equal "This has an unclosed ", sanitizer.sanitize("This has an unclosed <![CDATA[<section>]] here...")
-    [nil, '', '   '].each { |blank| assert_equal blank, sanitizer.sanitize(blank) }
-    assert_nothing_raised { sanitizer.sanitize("This is a frozen string with no tags".freeze) }
-  end
-
-  def test_strip_links
-    sanitizer = HTML::LinkSanitizer.new
-    assert_equal "Dont touch me", sanitizer.sanitize("Dont touch me")
-    assert_equal "on my mind\nall day long", sanitizer.sanitize("<a href='almost'>on my mind</a>\n<A href='almost'>all day long</A>")
-    assert_equal "0wn3d", sanitizer.sanitize("<a href='http://www.rubyonrails.com/'><a href='http://www.rubyonrails.com/' onlclick='steal()'>0wn3d</a></a>")
-    assert_equal "Magic", sanitizer.sanitize("<a href='http://www.rubyonrails.com/'>Mag<a href='http://www.ruby-lang.org/'>ic")
-    assert_equal "FrrFox", sanitizer.sanitize("<href onlclick='steal()'>FrrFox</a></href>")
-    assert_equal "My mind\nall <b>day</b> long", sanitizer.sanitize("<a href='almost'>My mind</a>\n<A href='almost'>all <b>day</b> long</A>")
-    assert_equal "all <b>day</b> long", sanitizer.sanitize("<<a>a href='hello'>all <b>day</b> long<</A>/a>")
-
-    assert_equal "<a<a", sanitizer.sanitize("<a<a")
-  end
-
-  def test_sanitize_form
-    assert_sanitized "<form action=\"/foo/bar\" method=\"post\"><input></form>", ''
-  end
-
-  def test_sanitize_plaintext
-    raw = "<plaintext><span>foo</span></plaintext>"
-    assert_sanitized raw, "<span>foo</span>"
-  end
-
-  def test_sanitize_script
-    assert_sanitized "a b c<script language=\"Javascript\">blah blah blah</script>d e f", "a b cd e f"
-  end
-
-  def test_sanitize_js_handlers
-    raw = %{onthis="do that" <a href="#" onclick="hello" name="foo" onbogus="remove me">hello</a>}
-    assert_sanitized raw, %{onthis="do that" <a name="foo" href="#">hello</a>}
-  end
-
-  def test_sanitize_javascript_href
-    raw = %{href="javascript:bang" <a href="javascript:bang" name="hello">foo</a>, <span href="javascript:bang">bar</span>}
-    assert_sanitized raw, %{href="javascript:bang" <a name="hello">foo</a>, <span>bar</span>}
-  end
-
-  def test_sanitize_image_src
-    raw = %{src="javascript:bang" <img src="javascript:bang" width="5">foo</img>, <span src="javascript:bang">bar</span>}
-    assert_sanitized raw, %{src="javascript:bang" <img width="5">foo</img>, <span>bar</span>}
-  end
-
-  HTML::WhiteListSanitizer.allowed_tags.each do |tag_name|
-    define_method "test_should_allow_#{tag_name}_tag" do
-      assert_sanitized "start <#{tag_name} title=\"1\" onclick=\"foo\">foo <bad>bar</bad> baz</#{tag_name}> end", %(start <#{tag_name} title="1">foo bar baz</#{tag_name}> end)
-    end
-  end
-
-  def test_should_allow_anchors
-    assert_sanitized %(<a href="foo" onclick="bar"><script>baz</script></a>), %(<a href="foo"></a>)
-  end
-
-  # RFC 3986, sec 4.2
-  def test_allow_colons_in_path_component
-    assert_sanitized("<a href=\"./this:that\">foo</a>")
-  end
-
-  %w(src width height alt).each do |img_attr|
-    define_method "test_should_allow_image_#{img_attr}_attribute" do
-      assert_sanitized %(<img #{img_attr}="foo" onclick="bar" />), %(<img #{img_attr}="foo" />)
-    end
-  end
-
-  def test_should_handle_non_html
-    assert_sanitized 'abc'
-  end
-
-  def test_should_handle_blank_text
-    assert_sanitized nil
-    assert_sanitized ''
-  end
-
-  def test_should_allow_custom_tags
-    text = "<u>foo</u>"
-    sanitizer = HTML::WhiteListSanitizer.new
-    assert_equal(text, sanitizer.sanitize(text, :tags => %w(u)))
-  end
-
-  def test_should_allow_only_custom_tags
-    text = "<u>foo</u> with <i>bar</i>"
-    sanitizer = HTML::WhiteListSanitizer.new
-    assert_equal("<u>foo</u> with bar", sanitizer.sanitize(text, :tags => %w(u)))
-  end
-
-  def test_should_allow_custom_tags_with_attributes
-    text = %(<blockquote cite="http://example.com/">foo</blockquote>)
-    sanitizer = HTML::WhiteListSanitizer.new
-    assert_equal(text, sanitizer.sanitize(text))
-  end
-
-  def test_should_allow_custom_tags_with_custom_attributes
-    text = %(<blockquote foo="bar">Lorem ipsum</blockquote>)
-    sanitizer = HTML::WhiteListSanitizer.new
-    assert_equal(text, sanitizer.sanitize(text, :attributes => ['foo']))
-  end
-
-  def test_should_raise_argument_error_if_tags_is_not_enumerable
-    sanitizer = HTML::WhiteListSanitizer.new
-    e = assert_raise(ArgumentError) do
-      sanitizer.sanitize('', :tags => 'foo')
-    end
-
-    assert_equal "You should pass :tags as an Enumerable", e.message
-  end
-
-  def test_should_raise_argument_error_if_attributes_is_not_enumerable
-    sanitizer = HTML::WhiteListSanitizer.new
-    e = assert_raise(ArgumentError) do
-      sanitizer.sanitize('', :attributes => 'foo')
-    end
-
-    assert_equal "You should pass :attributes as an Enumerable", e.message
-  end
-
-  [%w(img src), %w(a href)].each do |(tag, attr)|
-    define_method "test_should_strip_#{attr}_attribute_in_#{tag}_with_bad_protocols" do
-      assert_sanitized %(<#{tag} #{attr}="javascript:bang" title="1">boo</#{tag}>), %(<#{tag} title="1">boo</#{tag}>)
-    end
-  end
-
-  def test_should_flag_bad_protocols
-    sanitizer = HTML::WhiteListSanitizer.new
-    %w(about chrome data disk hcp help javascript livescript lynxcgi lynxexec ms-help ms-its mhtml mocha opera res resource shell vbscript view-source vnd.ms.radio wysiwyg).each do |proto|
-      assert sanitizer.send(:contains_bad_protocols?, 'src', "#{proto}://bad")
-    end
-  end
-
-  def test_should_accept_good_protocols_ignoring_case
-    sanitizer = HTML::WhiteListSanitizer.new
-    HTML::WhiteListSanitizer.allowed_protocols.each do |proto|
-      assert !sanitizer.send(:contains_bad_protocols?, 'src', "#{proto.capitalize}://good")
-    end
-  end
-
-  def test_should_accept_good_protocols_ignoring_space
-    sanitizer = HTML::WhiteListSanitizer.new
-    HTML::WhiteListSanitizer.allowed_protocols.each do |proto|
-      assert !sanitizer.send(:contains_bad_protocols?, 'src', " #{proto}://good")
-    end
-  end
-
-  def test_should_accept_good_protocols
-    sanitizer = HTML::WhiteListSanitizer.new
-    HTML::WhiteListSanitizer.allowed_protocols.each do |proto|
-      assert !sanitizer.send(:contains_bad_protocols?, 'src', "#{proto}://good")
-    end
-  end
-
-  def test_should_reject_hex_codes_in_protocol
-    assert_sanitized %(<a href="&#37;6A&#37;61&#37;76&#37;61&#37;73&#37;63&#37;72&#37;69&#37;70&#37;74&#37;3A&#37;61&#37;6C&#37;65&#37;72&#37;74&#37;28&#37;22&#37;58&#37;53&#37;53&#37;22&#37;29">1</a>), "<a>1</a>"
-    assert @sanitizer.send(:contains_bad_protocols?, 'src', "%6A%61%76%61%73%63%72%69%70%74%3A%61%6C%65%72%74%28%22%58%53%53%22%29")
-  end
-
-  def test_should_block_script_tag
-    assert_sanitized %(<SCRIPT\nSRC=http://ha.ckers.org/xss.js></SCRIPT>), ""
-  end
-
-  [%(<IMG SRC="javascript:alert('XSS');">),
-   %(<IMG SRC=javascript:alert('XSS')>),
-   %(<IMG SRC=JaVaScRiPt:alert('XSS')>),
-   %(<IMG """><SCRIPT>alert("XSS")</SCRIPT>">),
-   %(<IMG SRC=javascript:alert(&quot;XSS&quot;)>),
-   %(<IMG SRC=javascript:alert(String.fromCharCode(88,83,83))>),
-   %(<IMG SRC=&#106;&#97;&#118;&#97;&#115;&#99;&#114;&#105;&#112;&#116;&#58;&#97;&#108;&#101;&#114;&#116;&#40;&#39;&#88;&#83;&#83;&#39;&#41;>),
-   %(<IMG SRC=&#0000106&#0000097&#0000118&#0000097&#0000115&#0000099&#0000114&#0000105&#0000112&#0000116&#0000058&#0000097&#0000108&#0000101&#0000114&#0000116&#0000040&#0000039&#0000088&#0000083&#0000083&#0000039&#0000041>),
-   %(<IMG SRC=&#x6A&#x61&#x76&#x61&#x73&#x63&#x72&#x69&#x70&#x74&#x3A&#x61&#x6C&#x65&#x72&#x74&#x28&#x27&#x58&#x53&#x53&#x27&#x29>),
-   %(<IMG SRC="jav\tascript:alert('XSS');">),
-   %(<IMG SRC="jav&#x09;ascript:alert('XSS');">),
-   %(<IMG SRC="jav&#x0A;ascript:alert('XSS');">),
-   %(<IMG SRC="jav&#x0D;ascript:alert('XSS');">),
-   %(<IMG SRC=" &#14;  javascript:alert('XSS');">),
-   %(<IMG SRC="javascript&#x3a;alert('XSS');">),
-   %(<IMG SRC=`javascript:alert("RSnake says, 'XSS'")`>)].each_with_index do |img_hack, i|
-    define_method "test_should_not_fall_for_xss_image_hack_#{i+1}" do
-      assert_sanitized img_hack, "<img>"
-    end
-  end
-
-  def test_should_sanitize_tag_broken_up_by_null
-    assert_sanitized %(<SCR\0IPT>alert(\"XSS\")</SCR\0IPT>), "alert(\"XSS\")"
-  end
-
-  def test_should_sanitize_invalid_script_tag
-    assert_sanitized %(<SCRIPT/XSS SRC="http://ha.ckers.org/xss.js"></SCRIPT>), ""
-  end
-
-  def test_should_sanitize_script_tag_with_multiple_open_brackets
-    assert_sanitized %(<<SCRIPT>alert("XSS");//<</SCRIPT>), "&lt;"
-    assert_sanitized %(<iframe src=http://ha.ckers.org/scriptlet.html\n<a), %(&lt;a)
-  end
-
-  def test_should_sanitize_unclosed_script
-    assert_sanitized %(<SCRIPT SRC=http://ha.ckers.org/xss.js?<B>), "<b>"
-  end
-
-  def test_should_sanitize_half_open_scripts
-    assert_sanitized %(<IMG SRC="javascript:alert('XSS')"), "<img>"
-  end
-
-  def test_should_not_fall_for_ridiculous_hack
-    img_hack = %(<IMG\nSRC\n=\n"\nj\na\nv\na\ns\nc\nr\ni\np\nt\n:\na\nl\ne\nr\nt\n(\n'\nX\nS\nS\n'\n)\n"\n>)
-    assert_sanitized img_hack, "<img>"
-  end
-
-  def test_should_sanitize_attributes
-    assert_sanitized %(<SPAN title="'><script>alert()</script>">blah</SPAN>), %(<span title="#{CGI.escapeHTML "'><script>alert()</script>"}">blah</span>)
-  end
-
-  def test_should_sanitize_illegal_style_properties
-    raw      = %(display:block; position:absolute; left:0; top:0; width:100%; height:100%; z-index:1; background-color:black; background-image:url(http://www.ragingplatypus.com/i/cam-full.jpg); background-x:center; background-y:center; background-repeat:repeat;)
-    expected = %(display: block; width: 100%; height: 100%; background-color: black; background-image: ; background-x: center; background-y: center;)
-    assert_equal expected, sanitize_css(raw)
-  end
-
-  def test_should_sanitize_with_trailing_space
-    raw = "display:block; "
-    expected = "display: block;"
-    assert_equal expected, sanitize_css(raw)
-  end
-
-  def test_should_sanitize_xul_style_attributes
-    raw = %(-moz-binding:url('http://ha.ckers.org/xssmoz.xml#xss'))
-    assert_equal '', sanitize_css(raw)
-  end
-
-  def test_should_sanitize_invalid_tag_names
-    assert_sanitized(%(a b c<script/XSS src="http://ha.ckers.org/xss.js"></script>d e f), "a b cd e f")
-  end
-
-  def test_should_sanitize_non_alpha_and_non_digit_characters_in_tags
-    assert_sanitized('<a onclick!#$%&()*~+-_.,:;?@[/|\]^`=alert("XSS")>foo</a>', "<a>foo</a>")
-  end
-
-  def test_should_sanitize_invalid_tag_names_in_single_tags
-    assert_sanitized('<img/src="http://ha.ckers.org/xss.js"/>', "<img />")
-  end
-
-  def test_should_sanitize_img_dynsrc_lowsrc
-    assert_sanitized(%(<img lowsrc="javascript:alert('XSS')" />), "<img />")
-  end
-
-  def test_should_sanitize_div_background_image_unicode_encoded
-    raw = %(background-image:\0075\0072\006C\0028'\006a\0061\0076\0061\0073\0063\0072\0069\0070\0074\003a\0061\006c\0065\0072\0074\0028.1027\0058.1053\0053\0027\0029'\0029)
-    assert_equal '', sanitize_css(raw)
-  end
-
-  def test_should_sanitize_div_style_expression
-    raw = %(width: expression(alert('XSS'));)
-    assert_equal '', sanitize_css(raw)
-  end
-
-  def test_should_sanitize_across_newlines
-    raw = %(\nwidth:\nexpression(alert('XSS'));\n)
-    assert_equal '', sanitize_css(raw)
-  end
-
-  def test_should_sanitize_img_vbscript
-    assert_sanitized %(<img src='vbscript:msgbox("XSS")' />), '<img />'
-  end
-
-  def test_should_sanitize_cdata_section
-    assert_sanitized "<![CDATA[<span>section</span>]]>", "&lt;![CDATA[&lt;span>section&lt;/span>]]>"
-  end
-
-  def test_should_sanitize_unterminated_cdata_section
-    assert_sanitized "<![CDATA[<span>neverending...", "&lt;![CDATA[&lt;span>neverending...]]>"
-  end
-
-  def test_should_not_mangle_urls_with_ampersand
-     assert_sanitized %{<a href=\"http://www.domain.com?var1=1&amp;var2=2\">my link</a>}
-  end
-
-  def test_should_sanitize_neverending_attribute
-    assert_sanitized "<span class=\"\\", "<span class=\"\\\">"
-  end
-
-  def test_x03a
-    assert_sanitized %(<a href="javascript&#x3a;alert('XSS');">), "<a>"
-    assert_sanitized %(<a href="javascript&#x003a;alert('XSS');">), "<a>"
-    assert_sanitized %(<a href="http&#x3a;//legit">), %(<a href="http://legit">)
-    assert_sanitized %(<a href="javascript&#x3A;alert('XSS');">), "<a>"
-    assert_sanitized %(<a href="javascript&#x003A;alert('XSS');">), "<a>"
-    assert_sanitized %(<a href="http&#x3A;//legit">), %(<a href="http://legit">)
-  end
-
-protected
-  def assert_sanitized(input, expected = nil)
-    @sanitizer ||= HTML::WhiteListSanitizer.new
-    if input
-      assert_dom_equal expected || input, @sanitizer.sanitize(input)
-    else
-      assert_nil @sanitizer.sanitize(input)
-    end
-  end
-
-  def sanitize_css(input)
-    (@sanitizer ||= HTML::WhiteListSanitizer.new).sanitize_css(input)
-  end
-end
diff --git a/actionpack/test/template/html-scanner/tag_node_test.rb b/actionpack/test/template/html-scanner/tag_node_test.rb
deleted file mode 100644
index a29d2d43d7..0000000000
--- a/actionpack/test/template/html-scanner/tag_node_test.rb
+++ /dev/null
@@ -1,243 +0,0 @@
-require 'abstract_unit'
-
-class TagNodeTest < ActiveSupport::TestCase
-  def test_open_without_attributes
-    node = tag("<tag>")
-    assert_equal "tag", node.name
-    assert_equal Hash.new, node.attributes
-    assert_nil node.closing
-  end
-
-  def test_open_with_attributes
-    node = tag("<TAG1 foo=hey_ho x:bar=\"blah blah\" BAZ='blah blah blah' >")
-    assert_equal "tag1", node.name
-    assert_equal "hey_ho", node["foo"]
-    assert_equal "blah blah", node["x:bar"]
-    assert_equal "blah blah blah", node["baz"]
-  end
-
-  def test_self_closing_without_attributes
-    node = tag("<tag/>")
-    assert_equal "tag", node.name
-    assert_equal Hash.new, node.attributes
-    assert_equal :self, node.closing
-  end
-
-  def test_self_closing_with_attributes
-    node = tag("<tag a=b/>")
-    assert_equal "tag", node.name
-    assert_equal( { "a" => "b" }, node.attributes )
-    assert_equal :self, node.closing
-  end
-
-  def test_closing_without_attributes
-    node = tag("</tag>")
-    assert_equal "tag", node.name
-    assert_nil node.attributes
-    assert_equal :close, node.closing
-  end
-
-  def test_bracket_op_when_no_attributes
-    node = tag("</tag>")
-    assert_nil node["foo"]
-  end
-
-  def test_bracket_op_when_attributes
-    node = tag("<tag a=b/>")
-    assert_equal "b", node["a"]
-  end
-
-  def test_attributes_with_escaped_quotes
-    node = tag("<tag a='b\\'c' b=\"bob \\\"float\\\"\">")
-    assert_equal "b\\'c", node["a"]
-    assert_equal "bob \\\"float\\\"", node["b"]
-  end
-
-  def test_to_s
-    node = tag("<a b=c d='f' g=\"h 'i'\" />")
-    node = node.to_s
-    assert node.include?('a')
-    assert node.include?('b="c"')
-    assert node.include?('d="f"')
-    assert node.include?('g="h')
-    assert node.include?('i')
-  end
-
-  def test_tag
-    assert tag("<tag>").tag?
-  end
-
-  def test_match_tag_as_string
-    assert tag("<tag>").match(:tag => "tag")
-    assert !tag("<tag>").match(:tag => "b")
-  end
-
-  def test_match_tag_as_regexp
-    assert tag("<tag>").match(:tag => /t.g/)
-    assert !tag("<tag>").match(:tag => /t[bqs]g/)
-  end
-
-  def test_match_attributes_as_string
-    t = tag("<tag a=something b=else />")
-    assert t.match(:attributes => {"a" => "something"})
-    assert t.match(:attributes => {"b" => "else"})
-  end
-
-  def test_match_attributes_as_regexp
-    t = tag("<tag a=something b=else />")
-    assert t.match(:attributes => {"a" => /^something$/})
-    assert t.match(:attributes => {"b" =>  /e.*e/})
-    assert t.match(:attributes => {"a" => /me..i/, "b" => /.ls.$/})
-  end
-
-  def test_match_attributes_as_number
-    t = tag("<tag a=15 b=3.1415 />")
-    assert t.match(:attributes => {"a" => 15})
-    assert t.match(:attributes => {"b" => 3.1415})
-    assert t.match(:attributes => {"a" => 15, "b" => 3.1415})
-  end
-
-  def test_match_attributes_exist
-    t = tag("<tag a=15 b=3.1415 />")
-    assert t.match(:attributes => {"a" => true})
-    assert t.match(:attributes => {"b" => true})
-    assert t.match(:attributes => {"a" => true, "b" => true})
-  end
-
-  def test_match_attributes_not_exist
-    t = tag("<tag a=15 b=3.1415 />")
-    assert t.match(:attributes => {"c" => false})
-    assert t.match(:attributes => {"c" => nil})
-    assert t.match(:attributes => {"a" => true, "c" => false})
-  end
-
-  def test_match_parent_success
-    t = tag("<tag a=15 b='hello'>", tag("<foo k='value'>"))
-    assert t.match(:parent => {:tag => "foo", :attributes => {"k" => /v.l/, "j" => false}})
-  end
-
-  def test_match_parent_fail
-    t = tag("<tag a=15 b='hello'>", tag("<foo k='value'>"))
-    assert !t.match(:parent => {:tag => /kafka/})
-  end
-
-  def test_match_child_success
-    t = tag("<tag x:k='something'>")
-    tag("<child v=john a=kelly>", t)
-    tag("<sib m=vaughn v=james>", t)
-    assert t.match(:child => { :tag => "sib", :attributes => {"v" => /j/}})
-    assert t.match(:child => { :attributes => {"a" => "kelly"}})
-  end
-
-  def test_match_child_fail
-    t = tag("<tag x:k='something'>")
-    tag("<child v=john a=kelly>", t)
-    tag("<sib m=vaughn v=james>", t)
-    assert !t.match(:child => { :tag => "sib", :attributes => {"v" => /r/}})
-    assert !t.match(:child => { :attributes => {"v" => false}})
-  end
-
-  def test_match_ancestor_success
-    t = tag("<tag x:k='something'>", tag("<parent v=john a=kelly>", tag("<grandparent m=vaughn v=james>")))
-    assert t.match(:ancestor => {:tag => "parent", :attributes => {"a" => /ll/}})
-    assert t.match(:ancestor => {:attributes => {"m" => "vaughn"}})
-  end
-
-  def test_match_ancestor_fail
-    t = tag("<tag x:k='something'>", tag("<parent v=john a=kelly>", tag("<grandparent m=vaughn v=james>")))
-    assert !t.match(:ancestor => {:tag => /^parent/, :attributes => {"v" => /m/}})
-    assert !t.match(:ancestor => {:attributes => {"v" => false}})
-  end
-
-  def test_match_descendant_success
-    tag("<grandchild m=vaughn v=james>", tag("<child v=john a=kelly>", t = tag("<tag x:k='something'>")))
-    assert t.match(:descendant => {:tag => "child", :attributes => {"a" => /ll/}})
-    assert t.match(:descendant => {:attributes => {"m" => "vaughn"}})
-  end
-
-  def test_match_descendant_fail
-    tag("<grandchild m=vaughn v=james>", tag("<child v=john a=kelly>", t = tag("<tag x:k='something'>")))
-    assert !t.match(:descendant => {:tag => /^child/, :attributes => {"v" => /m/}})
-    assert !t.match(:descendant => {:attributes => {"v" => false}})
-  end
-
-  def test_match_child_count
-    t = tag("<tag x:k='something'>")
-    tag("hello", t)
-    tag("<child v=john a=kelly>", t)
-    tag("<sib m=vaughn v=james>", t)
-    assert t.match(:children => { :count => 2 })
-    assert t.match(:children => { :count => 2..4 })
-    assert t.match(:children => { :less_than => 4 })
-    assert t.match(:children => { :greater_than => 1 })
-    assert !t.match(:children => { :count => 3 })
-  end
-
-  def test_conditions_as_strings
-    t = tag("<tag x:k='something'>")
-    assert t.match("tag" => "tag")
-    assert t.match("attributes" => { "x:k" => "something" })
-    assert !t.match("tag" => "gat")
-    assert !t.match("attributes" => { "x:j" => "something" })
-  end
-
-  def test_attributes_as_symbols
-    t = tag("<child v=john a=kelly>")
-    assert t.match(:attributes => { :v => /oh/ })
-    assert t.match(:attributes => { :a => /ll/ })
-  end
-
-  def test_match_sibling
-    t = tag("<tag x:k='something'>")
-    tag("hello", t)
-    tag("<span a=b>", t)
-    tag("world", t)
-    m = tag("<span k=r>", t)
-    tag("<span m=l>", t)
-
-    assert m.match(:sibling => {:tag => "span", :attributes => {:a => true}})
-    assert m.match(:sibling => {:tag => "span", :attributes => {:m => true}})
-    assert !m.match(:sibling => {:tag => "span", :attributes => {:k => true}})
-  end
-
-  def test_match_sibling_before
-    t = tag("<tag x:k='something'>")
-    tag("hello", t)
-    tag("<span a=b>", t)
-    tag("world", t)
-    m = tag("<span k=r>", t)
-    tag("<span m=l>", t)
-
-    assert m.match(:before => {:tag => "span", :attributes => {:m => true}})
-    assert !m.match(:before => {:tag => "span", :attributes => {:a => true}})
-    assert !m.match(:before => {:tag => "span", :attributes => {:k => true}})
-  end
-
-  def test_match_sibling_after
-    t = tag("<tag x:k='something'>")
-    tag("hello", t)
-    tag("<span a=b>", t)
-    tag("world", t)
-    m = tag("<span k=r>", t)
-    tag("<span m=l>", t)
-
-    assert m.match(:after => {:tag => "span", :attributes => {:a => true}})
-    assert !m.match(:after => {:tag => "span", :attributes => {:m => true}})
-    assert !m.match(:after => {:tag => "span", :attributes => {:k => true}})
-  end
-
-  def test_tag_to_s
-    t = tag("<b x='foo'>")
-    tag("hello", t)
-    tag("<hr />", t)
-    assert_equal %(<b x="foo">hello<hr /></b>), t.to_s
-  end
-
-  private
-
-    def tag(content, parent=nil)
-      node = HTML::Node.parse(parent,0,0,content)
-      parent.children << node if parent
-      node
-    end
-end
diff --git a/actionpack/test/template/html-scanner/text_node_test.rb b/actionpack/test/template/html-scanner/text_node_test.rb
deleted file mode 100644
index cbcb9e78f0..0000000000
--- a/actionpack/test/template/html-scanner/text_node_test.rb
+++ /dev/null
@@ -1,50 +0,0 @@
-require 'abstract_unit'
-
-class TextNodeTest < ActiveSupport::TestCase
-  def setup
-    @node = HTML::Text.new(nil, 0, 0, "hello, howdy, aloha, annyeong")
-  end
-
-  def test_to_s
-    assert_equal "hello, howdy, aloha, annyeong", @node.to_s
-  end
-
-  def test_find_string
-    assert_equal @node, @node.find("hello, howdy, aloha, annyeong")
-    assert_equal false, @node.find("bogus")
-  end
-
-  def test_find_regexp
-    assert_equal @node, @node.find(/an+y/)
-    assert_nil @node.find(/b/)
-  end
-
-  def test_find_hash
-    assert_equal @node, @node.find(:content => /howdy/)
-    assert_nil @node.find(:content => /^howdy$/)
-    assert_equal false, @node.find(:content => "howdy")
-  end
-
-  def test_find_other
-    assert_nil @node.find(:hello)
-  end
-
-  def test_match_string
-    assert @node.match("hello, howdy, aloha, annyeong")
-    assert_equal false, @node.match("bogus")
-  end
-
-  def test_match_regexp
-    assert_not_nil @node, @node.match(/an+y/)
-    assert_nil @node.match(/b/)
-  end
-
-  def test_match_hash
-    assert_not_nil @node, @node.match(:content => "howdy")
-    assert_nil @node.match(:content => /^howdy$/)
-  end
-
-  def test_match_other
-    assert_nil @node.match(:hello)
-  end
-end
diff --git a/actionpack/test/template/html-scanner/tokenizer_test.rb b/actionpack/test/template/html-scanner/tokenizer_test.rb
deleted file mode 100644
index 1d59de23b6..0000000000
--- a/actionpack/test/template/html-scanner/tokenizer_test.rb
+++ /dev/null
@@ -1,131 +0,0 @@
-require 'abstract_unit'
-
-class TokenizerTest < ActiveSupport::TestCase
-
-  def test_blank
-    tokenize ""
-    assert_end
-  end
-
-  def test_space
-    tokenize " "
-    assert_next " "
-    assert_end
-  end
-
-  def test_tag_simple_open
-    tokenize "<tag>"
-    assert_next "<tag>"
-    assert_end
-  end
-
-  def test_tag_simple_self_closing
-    tokenize "<tag />"
-    assert_next "<tag />"
-    assert_end
-  end
-
-  def test_tag_simple_closing
-    tokenize "</tag>"
-    assert_next "</tag>"
-  end
-
-  def test_tag_with_single_quoted_attribute
-    tokenize %{<tag a='hello'>x}
-    assert_next %{<tag a='hello'>}
-  end
-
-  def test_tag_with_single_quoted_attribute_with_escape
-    tokenize %{<tag a='hello\\''>x}
-    assert_next %{<tag a='hello\\''>}
-  end
-
-  def test_tag_with_double_quoted_attribute
-    tokenize %{<tag a="hello">x}
-    assert_next %{<tag a="hello">}
-  end
-
-  def test_tag_with_double_quoted_attribute_with_escape
-    tokenize %{<tag a="hello\\"">x}
-    assert_next %{<tag a="hello\\"">}
-  end
-
-  def test_tag_with_unquoted_attribute
-    tokenize %{<tag a=hello>x}
-    assert_next %{<tag a=hello>}
-  end
-
-  def test_tag_with_lt_char_in_attribute
-    tokenize %{<tag a="x < y">x}
-    assert_next %{<tag a="x < y">}
-  end
-
-  def test_tag_with_gt_char_in_attribute
-    tokenize %{<tag a="x > y">x}
-    assert_next %{<tag a="x > y">}
-  end
-
-  def test_doctype_tag
-    tokenize %{<!DOCTYPE "blah" "blah" "blah">\n    <html>}
-    assert_next %{<!DOCTYPE "blah" "blah" "blah">}
-    assert_next %{\n    }
-    assert_next %{<html>}
-  end
-
-  def test_cdata_tag
-    tokenize %{<![CDATA[<br>]]>}
-    assert_next %{<![CDATA[<br>]]>}
-    assert_end
-  end
-
-  def test_unterminated_cdata_tag
-    tokenize %{<content:encoded><![CDATA[ neverending...}
-    assert_next %{<content:encoded>}
-    assert_next %{<![CDATA[ neverending...}
-    assert_end
-  end
-
-  def test_less_than_with_space
-    tokenize %{original < hello > world}
-    assert_next %{original }
-    assert_next %{< hello > world}
-  end
-
-  def test_less_than_without_matching_greater_than
-    tokenize %{hello <span onmouseover="gotcha"\n<b>foo</b>\nbar</span>}
-    assert_next %{hello }
-    assert_next %{<span onmouseover="gotcha"\n}
-    assert_next %{<b>}
-    assert_next %{foo}
-    assert_next %{</b>}
-    assert_next %{\nbar}
-    assert_next %{</span>}
-    assert_end
-  end
-
-  def test_unterminated_comment
-    tokenize %{hello <!-- neverending...}
-    assert_next %{hello }
-    assert_next %{<!-- neverending...}
-    assert_end
-  end
-
-  private
-
-    def tokenize(text)
-      @tokenizer = HTML::Tokenizer.new(text)
-    end
-
-    def assert_next(expected, message=nil)
-      token = @tokenizer.next
-      assert_equal expected, token, message
-    end
-
-    def assert_sequence(*expected)
-      assert_next expected.shift until expected.empty?
-    end
-
-    def assert_end(message=nil)
-      assert_nil @tokenizer.next, message
-    end
-end
diff --git a/actionpack/test/template/javascript_helper_test.rb b/actionpack/test/template/javascript_helper_test.rb
deleted file mode 100644
index 1eed8adb62..0000000000
--- a/actionpack/test/template/javascript_helper_test.rb
+++ /dev/null
@@ -1,104 +0,0 @@
-require 'abstract_unit'
-
-class JavaScriptHelperTest < ActionView::TestCase
-  tests ActionView::Helpers::JavaScriptHelper
-
-  def _evaluate_assigns_and_ivars() end
-
-  attr_accessor :formats, :output_buffer
-
-  def update_details(details)
-    @details = details
-    yield if block_given?
-  end
-
-  def setup
-    super
-    ActiveSupport.escape_html_entities_in_json  = true
-    @template = self
-  end
-
-  def teardown
-    ActiveSupport.escape_html_entities_in_json  = false
-  end
-
-  def test_escape_javascript
-    assert_equal '', escape_javascript(nil)
-    assert_equal %(This \\"thing\\" is really\\n netos\\'), escape_javascript(%(This "thing" is really\n netos'))
-    assert_equal %(backslash\\\\test), escape_javascript( %(backslash\\test) )
-    assert_equal %(dont <\\/close> tags), escape_javascript(%(dont </close> tags))
-    assert_equal %(unicode &#x2028; newline), escape_javascript(%(unicode \342\200\250 newline).force_encoding(Encoding::UTF_8).encode!)
-    assert_equal %(unicode &#x2029; newline), escape_javascript(%(unicode \342\200\251 newline).force_encoding(Encoding::UTF_8).encode!)
-
-    assert_equal %(dont <\\/close> tags), j(%(dont </close> tags))
-  end
-
-  def test_escape_javascript_with_safebuffer
-    given = %('quoted' "double-quoted" new-line:\n </closed>)
-    expect = %(\\'quoted\\' \\"double-quoted\\" new-line:\\n <\\/closed>)
-    assert_equal expect, escape_javascript(given)
-    assert_equal expect, escape_javascript(ActiveSupport::SafeBuffer.new(given))
-    assert_instance_of String, escape_javascript(given)
-    assert_instance_of ActiveSupport::SafeBuffer, escape_javascript(ActiveSupport::SafeBuffer.new(given))
-  end
-
-  def test_button_to_function
-    assert_deprecated do
-      assert_dom_equal %(<input type="button" onclick="alert(&#39;Hello world!&#39;);" value="Greeting" />),
-        button_to_function("Greeting", "alert('Hello world!')")
-    end
-  end
-
-  def test_button_to_function_with_onclick
-    assert_deprecated do
-      assert_dom_equal "<input onclick=\"alert(&#39;Goodbye World :(&#39;); alert(&#39;Hello world!&#39;);\" type=\"button\" value=\"Greeting\" />",
-        button_to_function("Greeting", "alert('Hello world!')", :onclick => "alert('Goodbye World :(')")
-    end
-  end
-
-  def test_button_to_function_without_function
-    assert_deprecated do
-      assert_dom_equal "<input onclick=\";\" type=\"button\" value=\"Greeting\" />",
-        button_to_function("Greeting")
-    end
-  end
-
-  def test_link_to_function
-    assert_deprecated do
-      assert_dom_equal %(<a href="#" onclick="alert(&#39;Hello world!&#39;); return false;">Greeting</a>),
-        link_to_function("Greeting", "alert('Hello world!')")
-    end
-  end
-
-  def test_link_to_function_with_existing_onclick
-    assert_deprecated do
-      assert_dom_equal %(<a href="#" onclick="confirm(&#39;Sanity!&#39;); alert(&#39;Hello world!&#39;); return false;">Greeting</a>),
-        link_to_function("Greeting", "alert('Hello world!')", :onclick => "confirm('Sanity!')")
-    end
-  end
-
-  def test_function_with_href
-    assert_deprecated do
-      assert_dom_equal %(<a href="http://example.com/" onclick="alert(&#39;Hello world!&#39;); return false;">Greeting</a>),
-        link_to_function("Greeting", "alert('Hello world!')", :href => 'http://example.com/')
-    end
-  end
-
-  def test_javascript_tag
-    self.output_buffer = 'foo'
-
-    assert_dom_equal "<script>\n//<![CDATA[\nalert('hello')\n//]]>\n</script>",
-      javascript_tag("alert('hello')")
-
-    assert_equal 'foo', output_buffer, 'javascript_tag without a block should not concat to output_buffer'
-  end
-
-  def test_javascript_tag_with_options
-    assert_dom_equal "<script id=\"the_js_tag\">\n//<![CDATA[\nalert('hello')\n//]]>\n</script>",
-      javascript_tag("alert('hello')", :id => "the_js_tag")
-  end
-
-  def test_javascript_cdata_section
-    assert_dom_equal "\n//<![CDATA[\nalert('hello')\n//]]>\n", javascript_cdata_section("alert('hello')")
-  end
-end
diff --git a/actionpack/test/template/log_subscriber_test.rb b/actionpack/test/template/log_subscriber_test.rb
deleted file mode 100644
index 7f4c84929f..0000000000
--- a/actionpack/test/template/log_subscriber_test.rb
+++ /dev/null
@@ -1,91 +0,0 @@
-require "abstract_unit"
-require "active_support/log_subscriber/test_helper"
-require "action_view/log_subscriber"
-require "controller/fake_models"
-
-class AVLogSubscriberTest < ActiveSupport::TestCase
-  include ActiveSupport::LogSubscriber::TestHelper
-
-  def setup
-    super
-    view_paths = ActionController::Base.view_paths
-    lookup_context = ActionView::LookupContext.new(view_paths, {}, ["test"])
-    renderer = ActionView::Renderer.new(lookup_context)
-    @view = ActionView::Base.new(renderer, {})
-    Rails.stubs(:root).returns(File.expand_path(FIXTURE_LOAD_PATH))
-    ActionView::LogSubscriber.attach_to :action_view
-  end
-
-  def teardown
-    super
-    ActiveSupport::LogSubscriber.log_subscribers.clear
-  end
-
-  def set_logger(logger)
-    ActionView::Base.logger = logger
-  end
-
-  def test_render_file_template
-    @view.render(:file => "test/hello_world")
-    wait
-
-    assert_equal 1, @logger.logged(:info).size
-    assert_match(/Rendered test\/hello_world\.erb/, @logger.logged(:info).last)
-  end
-
-  def test_render_text_template
-    @view.render(:text => "TEXT")
-    wait
-
-    assert_equal 1, @logger.logged(:info).size
-    assert_match(/Rendered text template/, @logger.logged(:info).last)
-  end
-
-  def test_render_inline_template
-    @view.render(:inline => "<%= 'TEXT' %>")
-    wait
-
-    assert_equal 1, @logger.logged(:info).size
-    assert_match(/Rendered inline template/, @logger.logged(:info).last)
-  end
-
-  def test_render_partial_template
-    @view.render(:partial => "test/customer")
-    wait
-
-    assert_equal 1, @logger.logged(:info).size
-    assert_match(/Rendered test\/_customer.erb/, @logger.logged(:info).last)
-  end
-
-  def test_render_partial_with_implicit_path
-    @view.render(Customer.new("david"), :greeting => "hi")
-    wait
-
-    assert_equal 1, @logger.logged(:info).size
-    assert_match(/Rendered customers\/_customer\.html\.erb/, @logger.logged(:info).last)
-  end
-
-  def test_render_collection_template
-    @view.render(:partial => "test/customer", :collection => [ Customer.new("david"), Customer.new("mary") ])
-    wait
-
-    assert_equal 1, @logger.logged(:info).size
-    assert_match(/Rendered test\/_customer.erb/, @logger.logged(:info).last)
-  end
-
-  def test_render_collection_with_implicit_path
-    @view.render([ Customer.new("david"), Customer.new("mary") ], :greeting => "hi")
-    wait
-
-    assert_equal 1, @logger.logged(:info).size
-    assert_match(/Rendered customers\/_customer\.html\.erb/, @logger.logged(:info).last)
-  end
-
-  def test_render_collection_template_without_path
-    @view.render([ GoodCustomer.new("david"), Customer.new("mary") ], :greeting => "hi")
-    wait
-
-    assert_equal 1, @logger.logged(:info).size
-    assert_match(/Rendered collection/, @logger.logged(:info).last)
-  end
-end
diff --git a/actionpack/test/template/lookup_context_test.rb b/actionpack/test/template/lookup_context_test.rb
deleted file mode 100644
index 073bd14783..0000000000
--- a/actionpack/test/template/lookup_context_test.rb
+++ /dev/null
@@ -1,263 +0,0 @@
-require "abstract_unit"
-require "abstract_controller/rendering"
-
-class LookupContextTest < ActiveSupport::TestCase
-  def setup
-    @lookup_context = ActionView::LookupContext.new(FIXTURE_LOAD_PATH, {})
-    ActionView::LookupContext::DetailsKey.clear
-  end
-
-  def teardown
-    I18n.locale = :en
-  end
-
-  test "allows to override default_formats with ActionView::Base.default_formats" do
-    begin
-      formats = ActionView::Base.default_formats
-      ActionView::Base.default_formats = [:foo, :bar]
-
-      assert_equal [:foo, :bar], ActionView::LookupContext.new([]).default_formats
-    ensure
-      ActionView::Base.default_formats = formats
-    end
-  end
-
-  test "process view paths on initialization" do
-    assert_kind_of ActionView::PathSet, @lookup_context.view_paths
-  end
-
-  test "normalizes details on initialization" do
-    assert_equal Mime::SET, @lookup_context.formats
-    assert_equal :en, @lookup_context.locale
-  end
-
-  test "allows me to freeze and retrieve frozen formats" do
-    @lookup_context.formats.freeze
-    assert @lookup_context.formats.frozen?
-  end
-
-  test "provides getters and setters for formats" do
-    @lookup_context.formats = [:html]
-    assert_equal [:html], @lookup_context.formats
-  end
-
-  test "handles */* formats" do
-    @lookup_context.formats = ["*/*"]
-    assert_equal Mime::SET, @lookup_context.formats
-  end
-
-  test "handles explicitly defined */* formats fallback to :js" do
-    @lookup_context.formats = [:js, Mime::ALL]
-    assert_equal [:js, *Mime::SET.symbols], @lookup_context.formats
-  end
-
-  test "adds :html fallback to :js formats" do
-    @lookup_context.formats = [:js]
-    assert_equal [:js, :html], @lookup_context.formats
-  end
-
-  test "provides getters and setters for locale" do
-    @lookup_context.locale = :pt
-    assert_equal :pt, @lookup_context.locale
-  end
-
-  test "changing lookup_context locale, changes I18n.locale" do
-    @lookup_context.locale = :pt
-    assert_equal :pt, I18n.locale
-  end
-
-  test "delegates changing the locale to the I18n configuration object if it contains a lookup_context object" do
-    begin
-      I18n.config = AbstractController::I18nProxy.new(I18n.config, @lookup_context)
-      @lookup_context.locale = :pt
-      assert_equal :pt, I18n.locale
-      assert_equal :pt, @lookup_context.locale
-    ensure
-      I18n.config = I18n.config.original_config
-    end
-
-    assert_equal :pt, I18n.locale
-  end
-
-  test "find templates using the given view paths and configured details" do
-    template = @lookup_context.find("hello_world", %w(test))
-    assert_equal "Hello world!", template.source
-
-    @lookup_context.locale = :da
-    template = @lookup_context.find("hello_world", %w(test))
-    assert_equal "Hey verden", template.source
-  end
-
-  test "found templates respects given formats if one cannot be found from template or handler" do
-    ActionView::Template::Handlers::Builder.expects(:default_format).returns(nil)
-    @lookup_context.formats = [:text]
-    template = @lookup_context.find("hello", %w(test))
-    assert_equal [:text], template.formats
-  end
-
-  test "adds fallbacks to view paths when required" do
-    assert_equal 1, @lookup_context.view_paths.size
-
-    @lookup_context.with_fallbacks do
-      assert_equal 3, @lookup_context.view_paths.size
-      assert @lookup_context.view_paths.include?(ActionView::FallbackFileSystemResolver.new(""))
-      assert @lookup_context.view_paths.include?(ActionView::FallbackFileSystemResolver.new("/"))
-    end
-  end
-
-  test "add fallbacks just once in nested fallbacks calls" do
-    @lookup_context.with_fallbacks do
-      @lookup_context.with_fallbacks do
-        assert_equal 3, @lookup_context.view_paths.size
-      end
-    end
-  end
-
-  test "generates a new details key for each details hash" do
-    keys = []
-    keys << @lookup_context.details_key
-    assert_equal 1, keys.uniq.size
-
-    @lookup_context.locale = :da
-    keys << @lookup_context.details_key
-    assert_equal 2, keys.uniq.size
-
-    @lookup_context.locale = :en
-    keys << @lookup_context.details_key
-    assert_equal 2, keys.uniq.size
-
-    @lookup_context.formats = [:html]
-    keys << @lookup_context.details_key
-    assert_equal 3, keys.uniq.size
-
-    @lookup_context.formats = nil
-    keys << @lookup_context.details_key
-    assert_equal 3, keys.uniq.size
-  end
-
-  test "gives the key forward to the resolver, so it can be used as cache key" do
-    @lookup_context.view_paths = ActionView::FixtureResolver.new("test/_foo.erb" => "Foo")
-    template = @lookup_context.find("foo", %w(test), true)
-    assert_equal "Foo", template.source
-
-    # Now we are going to change the template, but it won't change the returned template
-    # since we will hit the cache.
-    @lookup_context.view_paths.first.hash["test/_foo.erb"] = "Bar"
-    template = @lookup_context.find("foo", %w(test), true)
-    assert_equal "Foo", template.source
-
-    # This time we will change the locale. The updated template should be picked since
-    # lookup_context generated a new key after we changed the locale.
-    @lookup_context.locale = :da
-    template = @lookup_context.find("foo", %w(test), true)
-    assert_equal "Bar", template.source
-
-    # Now we will change back the locale and it will still pick the old template.
-    # This is expected because lookup_context will reuse the previous key for :en locale.
-    @lookup_context.locale = :en
-    template = @lookup_context.find("foo", %w(test), true)
-    assert_equal "Foo", template.source
-
-    # Finally, we can expire the cache. And the expected template will be used.
-    @lookup_context.view_paths.first.clear_cache
-    template = @lookup_context.find("foo", %w(test), true)
-    assert_equal "Bar", template.source
-  end
-
-  test "can disable the cache on demand" do
-    @lookup_context.view_paths = ActionView::FixtureResolver.new("test/_foo.erb" => "Foo")
-    old_template = @lookup_context.find("foo", %w(test), true)
-
-    template = @lookup_context.find("foo", %w(test), true)
-    assert_equal template, old_template
-
-    assert @lookup_context.cache
-    template = @lookup_context.disable_cache do
-      assert !@lookup_context.cache
-      @lookup_context.find("foo", %w(test), true)
-    end
-    assert @lookup_context.cache
-
-    assert_not_equal template, old_template
-  end
-
-  test "responds to #prefixes" do
-    assert_equal [], @lookup_context.prefixes
-    @lookup_context.prefixes = ["foo"]
-    assert_equal ["foo"], @lookup_context.prefixes
-  end
-end
-
-class LookupContextWithFalseCaching < ActiveSupport::TestCase
-  def setup
-    @resolver = ActionView::FixtureResolver.new("test/_foo.erb" => ["Foo", Time.utc(2000)])
-    ActionView::Resolver.stubs(:caching?).returns(false)
-    @lookup_context = ActionView::LookupContext.new(@resolver, {})
-  end
-
-  test "templates are always found in the resolver but timestamp is checked before being compiled" do
-    template = @lookup_context.find("foo", %w(test), true)
-    assert_equal "Foo", template.source
-
-    # Now we are going to change the template, but it won't change the returned template
-    # since the timestamp is the same.
-    @resolver.hash["test/_foo.erb"][0] = "Bar"
-    template = @lookup_context.find("foo", %w(test), true)
-    assert_equal "Foo", template.source
-
-    # Now update the timestamp.
-    @resolver.hash["test/_foo.erb"][1] = Time.now.utc
-    template = @lookup_context.find("foo", %w(test), true)
-    assert_equal "Bar", template.source
-  end
-
-  test "if no template was found in the second lookup, with no cache, raise error" do
-    template = @lookup_context.find("foo", %w(test), true)
-    assert_equal "Foo", template.source
-
-    @resolver.hash.clear
-    assert_raise ActionView::MissingTemplate do
-      @lookup_context.find("foo", %w(test), true)
-    end
-  end
-
-  test "if no template was cached in the first lookup, retrieval should work in the second call" do
-    @resolver.hash.clear
-    assert_raise ActionView::MissingTemplate do
-      @lookup_context.find("foo", %w(test), true)
-    end
-
-    @resolver.hash["test/_foo.erb"] = ["Foo", Time.utc(2000)]
-    template = @lookup_context.find("foo", %w(test), true)
-    assert_equal "Foo", template.source
-  end
-end
-
-class TestMissingTemplate < ActiveSupport::TestCase
-  def setup
-    @lookup_context = ActionView::LookupContext.new("/Path/to/views", {})
-  end
-
-  test "if no template was found we get a helpful error message including the inheritance chain" do
-    e = assert_raise ActionView::MissingTemplate do
-      @lookup_context.find("foo", %w(parent child))
-    end
-    assert_match %r{Missing template parent/foo, child/foo with .* Searched in:\n  \* "/Path/to/views"\n}, e.message
-  end
-
-  test "if no partial was found we get a helpful error message including the inheritance chain" do
-    e = assert_raise ActionView::MissingTemplate do
-      @lookup_context.find("foo", %w(parent child), true)
-    end
-    assert_match %r{Missing partial parent/foo, child/foo with .* Searched in:\n  \* "/Path/to/views"\n}, e.message
-  end
-
-  test "if a single prefix is passed as a string and the lookup fails, MissingTemplate accepts it" do
-    e = assert_raise ActionView::MissingTemplate do
-      details = {:handlers=>[], :formats=>[], :locale=>[]}
-      @lookup_context.view_paths.find("foo", "parent", true, details)
-    end
-    assert_match %r{Missing partial parent/foo with .* Searched in:\n  \* "/Path/to/views"\n}, e.message
-  end
-
-end
diff --git a/actionpack/test/template/number_helper_test.rb b/actionpack/test/template/number_helper_test.rb
deleted file mode 100644
index 6e640889d2..0000000000
--- a/actionpack/test/template/number_helper_test.rb
+++ /dev/null
@@ -1,151 +0,0 @@
-require "abstract_unit"
-
-class NumberHelperTest < ActionView::TestCase
-  tests ActionView::Helpers::NumberHelper
-
-  def test_number_to_phone
-    assert_equal nil, number_to_phone(nil)
-    assert_equal "555-1234", number_to_phone(5551234)
-    assert_equal "(800) 555-1212 x 123", number_to_phone(8005551212, area_code: true, extension: 123)
-    assert_equal "+18005551212", number_to_phone(8005551212, country_code: 1, delimiter: "")
-  end
-
-  def test_number_to_currency
-    assert_equal nil, number_to_currency(nil)
-    assert_equal "$1,234,567,890.50", number_to_currency(1234567890.50)
-    assert_equal "$1,234,567,892", number_to_currency(1234567891.50, precision: 0)
-    assert_equal "1,234,567,890.50 - K&#269;", number_to_currency("-1234567890.50", unit: "K&#269;", format: "%n %u", negative_format: "%n - %u")
-  end
-
-  def test_number_to_percentage
-    assert_equal nil, number_to_percentage(nil)
-    assert_equal "100.000%", number_to_percentage(100)
-    assert_equal "100%", number_to_percentage(100, precision: 0)
-    assert_equal "123.4%", number_to_percentage(123.400, precision: 3, strip_insignificant_zeros: true)
-    assert_equal "1.000,000%", number_to_percentage(1000, delimiter: ".", separator: ",")
-  end
-
-  def test_number_with_delimiter
-    assert_equal nil, number_with_delimiter(nil)
-    assert_equal "12,345,678", number_with_delimiter(12345678)
-    assert_equal "0", number_with_delimiter(0)
-  end
-
-  def test_number_with_precision
-    assert_equal nil, number_with_precision(nil)
-    assert_equal "-111.235", number_with_precision(-111.2346)
-    assert_equal "111.00", number_with_precision(111, precision: 2)
-    assert_equal "0.00100", number_with_precision(0.001, precision: 5)
-  end
-
-  def test_number_to_human_size
-    assert_equal nil, number_to_human_size(nil)
-    assert_equal "3 Bytes", number_to_human_size(3.14159265)
-    assert_equal "1.2 MB", number_to_human_size(1234567, precision: 2)
-  end
-
-  def test_number_to_human
-    assert_equal nil,   number_to_human(nil)
-    assert_equal "0",   number_to_human(0)
-    assert_equal "1.23 Thousand", number_to_human(1234)
-    assert_equal "489.0 Thousand", number_to_human(489000, precision: 4, strip_insignificant_zeros: false)
-  end
-
-  def test_number_helpers_escape_delimiter_and_separator
-    assert_equal "111&lt;script&gt;&lt;/script&gt;111&lt;script&gt;&lt;/script&gt;1111", number_to_phone(1111111111, delimiter: "<script></script>")
-
-    assert_equal "$1&lt;script&gt;&lt;/script&gt;01", number_to_currency(1.01, separator: "<script></script>")
-    assert_equal "$1&lt;script&gt;&lt;/script&gt;000.00", number_to_currency(1000, delimiter: "<script></script>")
-
-    assert_equal "1&lt;script&gt;&lt;/script&gt;010%", number_to_percentage(1.01, separator: "<script></script>")
-    assert_equal "1&lt;script&gt;&lt;/script&gt;000.000%", number_to_percentage(1000, delimiter: "<script></script>")
-
-    assert_equal "1&lt;script&gt;&lt;/script&gt;01", number_with_delimiter(1.01, separator: "<script></script>")
-    assert_equal "1&lt;script&gt;&lt;/script&gt;000", number_with_delimiter(1000, delimiter: "<script></script>")
-
-    assert_equal "1&lt;script&gt;&lt;/script&gt;010", number_with_precision(1.01, separator: "<script></script>")
-    assert_equal "1&lt;script&gt;&lt;/script&gt;000.000", number_with_precision(1000, delimiter: "<script></script>")
-
-    assert_equal "9&lt;script&gt;&lt;/script&gt;86 KB", number_to_human_size(10100, separator: "<script></script>")
-
-    assert_equal "1&lt;script&gt;&lt;/script&gt;01", number_to_human(1.01, separator: "<script></script>")
-    assert_equal "100&lt;script&gt;&lt;/script&gt;000 Quadrillion", number_to_human(10**20, delimiter: "<script></script>")
-  end
-
-  def test_number_helpers_outputs_are_html_safe
-    assert number_to_human(1).html_safe?
-    assert !number_to_human("<script></script>").html_safe?
-    assert number_to_human("asdf".html_safe).html_safe?
-    assert number_to_human("1".html_safe).html_safe?
-
-    assert number_to_human_size(1).html_safe?
-    assert number_to_human_size(1000000).html_safe?
-    assert !number_to_human_size("<script></script>").html_safe?
-    assert number_to_human_size("asdf".html_safe).html_safe?
-    assert number_to_human_size("1".html_safe).html_safe?
-
-    assert number_with_precision(1, strip_insignificant_zeros: false).html_safe?
-    assert number_with_precision(1, strip_insignificant_zeros: true).html_safe?
-    assert !number_with_precision("<script></script>").html_safe?
-    assert number_with_precision("asdf".html_safe).html_safe?
-    assert number_with_precision("1".html_safe).html_safe?
-
-    assert number_to_currency(1).html_safe?
-    assert !number_to_currency("<script></script>").html_safe?
-    assert number_to_currency("asdf".html_safe).html_safe?
-    assert number_to_currency("1".html_safe).html_safe?
-
-    assert number_to_percentage(1).html_safe?
-    assert !number_to_percentage("<script></script>").html_safe?
-    assert number_to_percentage("asdf".html_safe).html_safe?
-    assert number_to_percentage("1".html_safe).html_safe?
-
-    assert number_to_phone(1).html_safe?
-    assert_equal "&lt;script&gt;&lt;/script&gt;", number_to_phone("<script></script>")
-    assert number_to_phone("<script></script>").html_safe?
-    assert number_to_phone("asdf".html_safe).html_safe?
-    assert number_to_phone("1".html_safe).html_safe?
-
-    assert number_with_delimiter(1).html_safe?
-    assert !number_with_delimiter("<script></script>").html_safe?
-    assert number_with_delimiter("asdf".html_safe).html_safe?
-    assert number_with_delimiter("1".html_safe).html_safe?
-  end
-
-  def test_number_helpers_should_raise_error_if_invalid_when_specified
-    exception = assert_raise InvalidNumberError do
-      number_to_human("x", raise: true)
-    end
-    assert_equal "x", exception.number
-
-    exception = assert_raise InvalidNumberError do
-      number_to_human_size("x", raise: true)
-    end
-    assert_equal "x", exception.number
-
-    exception = assert_raise InvalidNumberError do
-      number_with_precision("x", raise: true)
-    end
-    assert_equal "x", exception.number
-
-    exception = assert_raise InvalidNumberError do
-      number_to_currency("x", raise: true)
-    end
-    assert_equal "x", exception.number
-
-    exception = assert_raise InvalidNumberError do
-      number_to_percentage("x", raise: true)
-    end
-    assert_equal "x", exception.number
-
-    exception = assert_raise InvalidNumberError do
-      number_with_delimiter("x", raise: true)
-    end
-    assert_equal "x", exception.number
-
-    exception = assert_raise InvalidNumberError do
-      number_to_phone("x", raise: true)
-    end
-    assert_equal "x", exception.number
-  end
-end
diff --git a/actionpack/test/template/output_buffer_test.rb b/actionpack/test/template/output_buffer_test.rb
deleted file mode 100644
index eb0df3d1ab..0000000000
--- a/actionpack/test/template/output_buffer_test.rb
+++ /dev/null
@@ -1,59 +0,0 @@
-require 'abstract_unit'
-
-class OutputBufferTest < ActionController::TestCase
-  class TestController < ActionController::Base
-    def index
-      render :text => 'foo'
-    end
-  end
-
-  tests TestController
-
-  def setup
-    @vc = @controller.view_context
-    get :index
-    assert_equal ['foo'], body_parts
-  end
-
-  test 'output buffer is nil after rendering' do
-    assert_nil output_buffer
-  end
-
-  test 'flushing ignores nil output buffer' do
-    @controller.view_context.flush_output_buffer
-    assert_nil output_buffer
-    assert_equal ['foo'], body_parts
-  end
-
-  test 'flushing ignores empty output buffer' do
-    @vc.output_buffer = ''
-    @vc.flush_output_buffer
-    assert_equal '', output_buffer
-    assert_equal ['foo'], body_parts
-  end
-
-  test 'flushing appends the output buffer to the body parts' do
-    @vc.output_buffer = 'bar'
-    @vc.flush_output_buffer
-    assert_equal '', output_buffer
-    assert_equal ['foo', 'bar'], body_parts
-  end
-
-  test 'flushing preserves output buffer encoding' do
-    original_buffer = ' '.force_encoding(Encoding::EUC_JP)
-    @vc.output_buffer = original_buffer
-    @vc.flush_output_buffer
-    assert_equal ['foo', original_buffer], body_parts
-    assert_not_equal original_buffer, output_buffer
-    assert_equal Encoding::EUC_JP, output_buffer.encoding
-  end
-
-  protected
-    def output_buffer
-      @vc.output_buffer
-    end
-
-    def body_parts
-      @controller.response.body_parts
-    end
-end
diff --git a/actionpack/test/template/output_safety_helper_test.rb b/actionpack/test/template/output_safety_helper_test.rb
deleted file mode 100644
index 76c71c9e6d..0000000000
--- a/actionpack/test/template/output_safety_helper_test.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-require 'abstract_unit'
-
-class OutputSafetyHelperTest < ActionView::TestCase
-  tests ActionView::Helpers::OutputSafetyHelper
-
-  def setup
-    @string = "hello"
-  end
-
-  test "raw returns the safe string" do
-    result = raw(@string)
-    assert_equal @string, result
-    assert result.html_safe?
-  end
-
-  test "raw handles nil values correctly" do
-    assert_equal "", raw(nil)
-  end
-
-  test "safe_join should html_escape any items, including the separator, if they are not html_safe" do
-    joined = safe_join(["<p>foo</p>".html_safe, "<p>bar</p>"], "<br />")
-    assert_equal "<p>foo</p>&lt;br /&gt;&lt;p&gt;bar&lt;/p&gt;", joined
-
-    joined = safe_join(["<p>foo</p>".html_safe, "<p>bar</p>".html_safe], "<br />".html_safe)
-    assert_equal "<p>foo</p><br /><p>bar</p>", joined
-  end
-
-end
\ No newline at end of file
diff --git a/actionpack/test/template/record_identifier_test.rb b/actionpack/test/template/record_identifier_test.rb
deleted file mode 100644
index 22038110a5..0000000000
--- a/actionpack/test/template/record_identifier_test.rb
+++ /dev/null
@@ -1,49 +0,0 @@
-require 'abstract_unit'
-require 'controller/fake_models'
-
-class RecordIdentifierTest < ActiveSupport::TestCase
-  include ActionView::RecordIdentifier
-
-  def setup
-    @klass  = Comment
-    @record = @klass.new
-    @singular = 'comment'
-    @plural = 'comments'
-    @uncountable = Sheep
-  end
-
-  def test_dom_id_with_new_record
-    assert_equal "new_#{@singular}", dom_id(@record)
-  end
-
-  def test_dom_id_with_new_record_and_prefix
-    assert_equal "custom_prefix_#{@singular}", dom_id(@record, :custom_prefix)
-  end
-
-  def test_dom_id_with_saved_record
-    @record.save
-    assert_equal "#{@singular}_1", dom_id(@record)
-  end
-
-  def test_dom_id_with_prefix
-    @record.save
-    assert_equal "edit_#{@singular}_1", dom_id(@record, :edit)
-  end
-
-  def test_dom_class
-    assert_equal @singular, dom_class(@record)
-  end
-
-  def test_dom_class_with_prefix
-    assert_equal "custom_prefix_#{@singular}", dom_class(@record, :custom_prefix)
-  end
-
-  def test_dom_id_as_singleton_method
-    @record.save
-    assert_equal "#{@singular}_1", ActionView::RecordIdentifier.dom_id(@record)
-  end
-
-  def test_dom_class_as_singleton_method
-    assert_equal @singular, ActionView::RecordIdentifier.dom_class(@record)
-  end
-end
diff --git a/actionpack/test/template/record_tag_helper_test.rb b/actionpack/test/template/record_tag_helper_test.rb
deleted file mode 100644
index ab84bccb56..0000000000
--- a/actionpack/test/template/record_tag_helper_test.rb
+++ /dev/null
@@ -1,117 +0,0 @@
-require 'abstract_unit'
-
-class RecordTagPost
-  extend ActiveModel::Naming
-  include ActiveModel::Conversion
-  attr_accessor :id, :body
-
-  def initialize
-    @id   = 45
-    @body = "What a wonderful world!"
-
-    yield self if block_given?
-  end
-end
-
-class RecordTagHelperTest < ActionView::TestCase
-  include RenderERBUtils
-
-  tests ActionView::Helpers::RecordTagHelper
-
-  def setup
-    super
-    @post = RecordTagPost.new
-  end
-
-  def test_content_tag_for
-    expected = %(<li class="record_tag_post" id="record_tag_post_45"></li>)
-    actual = content_tag_for(:li, @post)
-    assert_dom_equal expected, actual
-  end
-
-  def test_content_tag_for_prefix
-    expected = %(<ul class="archived_record_tag_post" id="archived_record_tag_post_45"></ul>)
-    actual = content_tag_for(:ul, @post, :archived)
-    assert_dom_equal expected, actual
-  end
-
-  def test_content_tag_for_with_extra_html_options
-    expected = %(<tr class="record_tag_post special" id="record_tag_post_45" style='background-color: #f0f0f0'></tr>)
-    actual = content_tag_for(:tr, @post, class: "special", style: "background-color: #f0f0f0")
-    assert_dom_equal expected, actual
-  end
-
-  def test_content_tag_for_with_array_css_class
-    expected = %(<tr class="record_tag_post special odd" id="record_tag_post_45"></tr>)
-    actual = content_tag_for(:tr, @post, class: ["special", "odd"])
-    assert_dom_equal expected, actual
-  end
-
-  def test_content_tag_for_with_prefix_and_extra_html_options
-    expected = %(<tr class="archived_record_tag_post special" id="archived_record_tag_post_45" style='background-color: #f0f0f0'></tr>)
-    actual = content_tag_for(:tr, @post, :archived, class: "special", style: "background-color: #f0f0f0")
-    assert_dom_equal expected, actual
-  end
-
-  def test_block_not_in_erb_multiple_calls
-    expected = %(<div class="record_tag_post special" id="record_tag_post_45">What a wonderful world!</div>)
-    actual = div_for(@post, class: "special") { @post.body }
-    assert_dom_equal expected, actual
-    actual = div_for(@post, class: "special") { @post.body }
-    assert_dom_equal expected, actual
-  end
-
-  def test_block_works_with_content_tag_for_in_erb
-    expected = %(<tr class="record_tag_post" id="record_tag_post_45">What a wonderful world!</tr>)
-    actual = render_erb("<%= content_tag_for(:tr, @post) do %><%= @post.body %><% end %>")
-    assert_dom_equal expected, actual
-  end
-
-  def test_div_for_in_erb
-    expected = %(<div class="record_tag_post special" id="record_tag_post_45">What a wonderful world!</div>)
-    actual = render_erb("<%= div_for(@post, class: 'special') do %><%= @post.body %><% end %>")
-    assert_dom_equal expected, actual
-  end
-
-  def test_content_tag_for_collection
-    post_1 = RecordTagPost.new { |post| post.id = 101; post.body = "Hello!" }
-    post_2 = RecordTagPost.new { |post| post.id = 102; post.body = "World!" }
-    expected = %(<li class="record_tag_post" id="record_tag_post_101">Hello!</li>\n<li class="record_tag_post" id="record_tag_post_102">World!</li>)
-    actual = content_tag_for(:li, [post_1, post_2]) { |post| post.body }
-    assert_dom_equal expected, actual
-  end
-
-  def test_content_tag_for_collection_without_given_block
-    post_1 = RecordTagPost.new.tap { |post| post.id = 101; post.body = "Hello!" }
-    post_2 = RecordTagPost.new.tap { |post| post.id = 102; post.body = "World!" }
-    expected = %(<li class="record_tag_post" id="record_tag_post_101"></li>\n<li class="record_tag_post" id="record_tag_post_102"></li>)
-    actual = content_tag_for(:li, [post_1, post_2])
-    assert_dom_equal expected, actual
-  end
-
-  def test_div_for_collection
-    post_1 = RecordTagPost.new { |post| post.id = 101; post.body = "Hello!" }
-    post_2 = RecordTagPost.new { |post| post.id = 102; post.body = "World!" }
-    expected = %(<div class="record_tag_post" id="record_tag_post_101">Hello!</div>\n<div class="record_tag_post" id="record_tag_post_102">World!</div>)
-    actual = div_for([post_1, post_2]) { |post| post.body }
-    assert_dom_equal expected, actual
-  end
-
-  def test_content_tag_for_single_record_is_html_safe
-    result = div_for(@post, class: "special") { @post.body }
-    assert result.html_safe?
-  end
-
-  def test_content_tag_for_collection_is_html_safe
-    post_1 = RecordTagPost.new { |post| post.id = 101; post.body = "Hello!" }
-    post_2 = RecordTagPost.new { |post| post.id = 102; post.body = "World!" }
-    result = content_tag_for(:li, [post_1, post_2]) { |post| post.body }
-    assert result.html_safe?
-  end
-
-  def test_content_tag_for_does_not_change_options_hash
-    options = { class: "important" }
-    content_tag_for(:li, @post, options)
-    assert_equal({ class: "important" }, options)
-  end
-end
diff --git a/actionpack/test/template/render_test.rb b/actionpack/test/template/render_test.rb
deleted file mode 100644
index 81f3391fcd..0000000000
--- a/actionpack/test/template/render_test.rb
+++ /dev/null
@@ -1,537 +0,0 @@
-# encoding: utf-8
-require 'abstract_unit'
-require 'controller/fake_models'
-
-class TestController < ActionController::Base
-end
-
-module RenderTestCases
-  def setup_view(paths)
-    @assigns = { :secret => 'in the sauce' }
-    @view = ActionView::Base.new(paths, @assigns)
-    @controller_view = TestController.new.view_context
-
-    # Reload and register danish language for testing
-    I18n.reload!
-    I18n.backend.store_translations 'da', {}
-    I18n.backend.store_translations 'pt-BR', {}
-
-    # Ensure original are still the same since we are reindexing view paths
-    assert_equal ORIGINAL_LOCALES, I18n.available_locales.map {|l| l.to_s }.sort
-  end
-
-  def test_render_without_options
-    e = assert_raises(ArgumentError) { @view.render() }
-    assert_match "You invoked render but did not give any of :partial, :template, :inline, :file or :text option.", e.message
-  end
-
-  def test_render_file
-    assert_equal "Hello world!", @view.render(:file => "test/hello_world")
-  end
-
-  # Test if :formats, :locale etc. options are passed correctly to the resolvers.
-  def test_render_file_with_format
-    assert_match "<h1>No Comment</h1>", @view.render(:file => "comments/empty", :formats => [:html])
-    assert_match "<error>No Comment</error>", @view.render(:file => "comments/empty", :formats => [:xml])
-    assert_match "<error>No Comment</error>", @view.render(:file => "comments/empty", :formats => :xml)
-  end
-
-  def test_render_template_with_format
-    assert_match "<h1>No Comment</h1>", @view.render(:template => "comments/empty", :formats => [:html])
-    assert_match "<error>No Comment</error>", @view.render(:template => "comments/empty", :formats => [:xml])
-  end
-
-  def test_render_partial_implicitly_use_format_of_the_rendered_template
-    @view.lookup_context.formats = [:json]
-    assert_equal "Hello world", @view.render(:template => "test/one", :formats => [:html])
-  end
-
-  def test_render_partial_implicitly_use_format_of_the_rendered_partial
-    @view.lookup_context.formats = [:html]
-    assert_equal "Third level", @view.render(:template => "test/html_template")
-  end
-
-  def test_render_partial_use_last_prepended_format_for_partials_with_the_same_names
-    @view.lookup_context.formats = [:html]
-    assert_equal "\nHTML Template, but JSON partial", @view.render(:template => "test/change_priority")
-  end
-
-  def test_render_template_with_a_missing_partial_of_another_format
-    @view.lookup_context.formats = [:html]
-    assert_raise ActionView::Template::Error, "Missing partial /missing with {:locale=>[:en], :formats=>[:json], :handlers=>[:erb, :builder]}" do
-      @view.render(:template => "with_format", :formats => [:json])
-    end
-  end
-
-  def test_render_file_with_locale
-    assert_equal "<h1>Kein Kommentar</h1>", @view.render(:file => "comments/empty", :locale => [:de])
-    assert_equal "<h1>Kein Kommentar</h1>", @view.render(:file => "comments/empty", :locale => :de)
-  end
-
-  def test_render_template_with_locale
-    assert_equal "<h1>Kein Kommentar</h1>", @view.render(:template => "comments/empty", :locale => [:de])
-  end
-
-  def test_render_file_with_handlers
-    assert_equal "<h1>No Comment</h1>\n", @view.render(:file => "comments/empty", :handlers => [:builder])
-    assert_equal "<h1>No Comment</h1>\n", @view.render(:file => "comments/empty", :handlers => :builder)
-  end
-
-  def test_render_template_with_handlers
-    assert_equal "<h1>No Comment</h1>\n", @view.render(:template => "comments/empty", :handlers => [:builder])
-  end
-
-  def test_render_raw_template_with_handlers
-    assert_equal "<%= hello_world %>\n", @view.render(:template => "plain_text")
-  end
-
-  def test_render_raw_template_with_quotes
-    assert_equal %q;Here are some characters: !@#$%^&*()-="'}{`; + "\n", @view.render(:template => "plain_text_with_characters")
-  end
-
-  def test_render_ruby_template_with_handlers
-    assert_equal "Hello from Ruby code", @view.render(:template => "ruby_template")
-  end
-
-  def test_render_ruby_template_inline
-    assert_equal '4', @view.render(:inline => "(2**2).to_s", :type => :ruby)
-  end
-
-  def test_render_file_with_localization_on_context_level
-    old_locale, @view.locale = @view.locale, :da
-    assert_equal "Hey verden", @view.render(:file => "test/hello_world")
-  ensure
-    @view.locale = old_locale
-  end
-
-  def test_render_file_with_dashed_locale
-    old_locale, @view.locale = @view.locale, :"pt-BR"
-    assert_equal "Ola mundo", @view.render(:file => "test/hello_world")
-  ensure
-    @view.locale = old_locale
-  end
-
-  def test_render_file_at_top_level
-    assert_equal 'Elastica', @view.render(:file => '/shared')
-  end
-
-  def test_render_file_with_full_path
-    template_path = File.join(File.dirname(__FILE__), '../fixtures/test/hello_world')
-    assert_equal "Hello world!", @view.render(:file => template_path)
-  end
-
-  def test_render_file_with_instance_variables
-    assert_equal "The secret is in the sauce\n", @view.render(:file => "test/render_file_with_ivar")
-  end
-
-  def test_render_file_with_locals
-    locals = { :secret => 'in the sauce' }
-    assert_equal "The secret is in the sauce\n", @view.render(:file => "test/render_file_with_locals", :locals => locals)
-  end
-
-  def test_render_file_not_using_full_path_with_dot_in_path
-    assert_equal "The secret is in the sauce\n", @view.render(:file => "test/dot.directory/render_file_with_ivar")
-  end
-
-  def test_render_partial_from_default
-    assert_equal "only partial", @view.render("test/partial_only")
-  end
-
-  def test_render_partial
-    assert_equal "only partial", @view.render(:partial => "test/partial_only")
-  end
-
-  def test_render_partial_with_format
-    assert_equal 'partial html', @view.render(:partial => 'test/partial')
-  end
-
-  def test_render_partial_with_selected_format
-    assert_equal 'partial html', @view.render(:partial => 'test/partial', :formats => :html)
-    assert_equal 'partial js', @view.render(:partial => 'test/partial', :formats => [:js])
-  end
-
-  def test_render_partial_at_top_level
-    # file fixtures/_top_level_partial_only (not fixtures/test)
-    assert_equal 'top level partial', @view.render(:partial => '/top_level_partial_only')
-  end
-
-  def test_render_partial_with_format_at_top_level
-    # file fixtures/_top_level_partial.html (not fixtures/test, with format extension)
-    assert_equal 'top level partial html', @view.render(:partial => '/top_level_partial')
-  end
-
-  def test_render_partial_with_locals
-    assert_equal "5", @view.render(:partial => "test/counter", :locals => { :counter_counter => 5 })
-  end
-
-  def test_render_partial_with_locals_from_default
-    assert_equal "only partial", @view.render("test/partial_only", :counter_counter => 5)
-  end
-
-  def test_render_partial_with_invalid_name
-    e = assert_raises(ArgumentError) { @view.render(:partial => "test/200") }
-    assert_equal "The partial name (test/200) is not a valid Ruby identifier; " +
-      "make sure your partial name starts with a lowercase letter or underscore, " +
-      "and is followed by any combination of letters, numbers and underscores.", e.message
-  end
-
-  def test_render_partial_with_missing_filename
-    e = assert_raises(ArgumentError) { @view.render(:partial => "test/") }
-    assert_equal "The partial name (test/) is not a valid Ruby identifier; " +
-      "make sure your partial name starts with a lowercase letter or underscore, " +
-      "and is followed by any combination of letters, numbers and underscores.", e.message
-  end
-
-  def test_render_partial_with_incompatible_object
-    e = assert_raises(ArgumentError) { @view.render(:partial => nil) }
-    assert_equal "'#{nil.inspect}' is not an ActiveModel-compatible object. It must implement :to_partial_path.", e.message
-  end
-
-  def test_render_partial_with_hyphen
-    e = assert_raises(ArgumentError) { @view.render(:partial => "test/a-in") }
-    assert_equal "The partial name (test/a-in) is not a valid Ruby identifier; " +
-      "make sure your partial name starts with a lowercase letter or underscore, " +
-      "and is followed by any combination of letters, numbers and underscores.", e.message
-  end
-
-  def test_render_partial_with_errors
-    e = assert_raises(ActionView::Template::Error) { @view.render(:partial => "test/raise") }
-    assert_match %r!method.*doesnt_exist!, e.message
-    assert_equal "", e.sub_template_message
-    assert_equal "1", e.line_number
-    assert_equal "1: <%= doesnt_exist %>", e.annoted_source_code.strip
-    assert_equal File.expand_path("#{FIXTURE_LOAD_PATH}/test/_raise.html.erb"), e.file_name
-  end
-
-  def test_render_error_indentation
-    e = assert_raises(ActionView::Template::Error) { @view.render(:partial => "test/raise_indentation") }
-    error_lines = e.annoted_source_code.split("\n")
-    assert_match %r!error\shere!, e.message
-    assert_equal "11", e.line_number
-    assert_equal "     9: <p>Ninth paragraph</p>", error_lines.second
-    assert_equal "    10: <p>Tenth paragraph</p>", error_lines.third
-  end
-
-  def test_render_sub_template_with_errors
-    e = assert_raises(ActionView::Template::Error) { @view.render(:template => "test/sub_template_raise") }
-    assert_match %r!method.*doesnt_exist!, e.message
-    assert_equal "Trace of template inclusion: #{File.expand_path("#{FIXTURE_LOAD_PATH}/test/sub_template_raise.html.erb")}", e.sub_template_message
-    assert_equal "1", e.line_number
-    assert_equal File.expand_path("#{FIXTURE_LOAD_PATH}/test/_raise.html.erb"), e.file_name
-  end
-
-  def test_render_file_with_errors
-    e = assert_raises(ActionView::Template::Error) { @view.render(:file => File.expand_path("test/_raise", FIXTURE_LOAD_PATH)) }
-    assert_match %r!method.*doesnt_exist!, e.message
-    assert_equal "", e.sub_template_message
-    assert_equal "1", e.line_number
-    assert_equal "1: <%= doesnt_exist %>", e.annoted_source_code.strip
-    assert_equal File.expand_path("#{FIXTURE_LOAD_PATH}/test/_raise.html.erb"), e.file_name
-  end
-
-  def test_render_object
-    assert_equal "Hello: david", @view.render(:partial => "test/customer", :object => Customer.new("david"))
-  end
-
-  def test_render_object_with_array
-    assert_equal "[1, 2, 3]", @view.render(:partial => "test/object_inspector", :object => [1, 2, 3])
-  end
-
-  def test_render_partial_collection
-    assert_equal "Hello: davidHello: mary", @view.render(:partial => "test/customer", :collection => [ Customer.new("david"), Customer.new("mary") ])
-  end
-
-  def test_render_partial_collection_as_by_string
-    assert_equal "david david davidmary mary mary",
-      @view.render(:partial => "test/customer_with_var", :collection => [ Customer.new("david"), Customer.new("mary") ], :as => 'customer')
-  end
-
-  def test_render_partial_collection_as_by_symbol
-    assert_equal "david david davidmary mary mary",
-      @view.render(:partial => "test/customer_with_var", :collection => [ Customer.new("david"), Customer.new("mary") ], :as => :customer)
-  end
-
-  def test_render_partial_collection_without_as
-    assert_equal "local_inspector,local_inspector_counter",
-      @view.render(:partial => "test/local_inspector", :collection => [ Customer.new("mary") ])
-  end
-
-  def test_render_partial_with_empty_collection_should_return_nil
-    assert_nil @view.render(:partial => "test/customer", :collection => [])
-  end
-
-  def test_render_partial_with_nil_collection_should_return_nil
-    assert_nil @view.render(:partial => "test/customer", :collection => nil)
-  end
-
-  def test_render_partial_with_nil_values_in_collection
-    assert_equal "Hello: davidHello: Anonymous", @view.render(:partial => "test/customer", :collection => [ Customer.new("david"), nil ])
-  end
-
-  def test_render_partial_with_layout_using_collection_and_template
-    assert_equal "<b>Hello: Amazon</b><b>Hello: Yahoo</b>", @view.render(:partial => "test/customer", :layout => 'test/b_layout_for_partial', :collection => [ Customer.new("Amazon"), Customer.new("Yahoo") ])
-  end
-
-  def test_render_partial_with_layout_using_collection_and_template_makes_current_item_available_in_layout
-    assert_equal '<b class="amazon">Hello: Amazon</b><b class="yahoo">Hello: Yahoo</b>',
-      @view.render(:partial => "test/customer", :layout => 'test/b_layout_for_partial_with_object', :collection => [ Customer.new("Amazon"), Customer.new("Yahoo") ])
-  end
-
-  def test_render_partial_with_layout_using_collection_and_template_makes_current_item_counter_available_in_layout
-    assert_equal '<b data-counter="0">Hello: Amazon</b><b data-counter="1">Hello: Yahoo</b>',
-      @view.render(:partial => "test/customer", :layout => 'test/b_layout_for_partial_with_object_counter', :collection => [ Customer.new("Amazon"), Customer.new("Yahoo") ])
-  end
-
-  def test_render_partial_with_layout_using_object_and_template_makes_object_available_in_layout
-    assert_equal '<b class="amazon">Hello: Amazon</b>',
-      @view.render(:partial => "test/customer", :layout => 'test/b_layout_for_partial_with_object', :object => Customer.new("Amazon"))
-  end
-
-  def test_render_partial_with_empty_array_should_return_nil
-    assert_nil @view.render(:partial => [])
-  end
-
-  def test_render_partial_using_string
-    assert_equal "Hello: Anonymous", @controller_view.render('customer')
-  end
-
-  def test_render_partial_with_locals_using_string
-    assert_equal "Hola: david", @controller_view.render('customer_greeting', :greeting => 'Hola', :customer_greeting => Customer.new("david"))
-  end
-
-  def test_render_partial_using_object
-    assert_equal "Hello: lifo",
-      @controller_view.render(Customer.new("lifo"), :greeting => "Hello")
-  end
-
-  def test_render_partial_using_collection
-    customers = [ Customer.new("Amazon"), Customer.new("Yahoo") ]
-    assert_equal "Hello: AmazonHello: Yahoo",
-      @controller_view.render(customers, :greeting => "Hello")
-  end
-
-  def test_render_partial_without_object_or_collection_does_not_generate_partial_name_local_variable
-    exception = assert_raises ActionView::Template::Error do
-      @controller_view.render("partial_name_local_variable")
-    end
-    assert_match "undefined local variable or method `partial_name_local_variable'", exception.message
-  end
-
-  # TODO: The reason for this test is unclear, improve documentation
-  def test_render_partial_and_fallback_to_layout
-    assert_equal "Before (Josh)\n\nAfter", @view.render(:partial => "test/layout_for_partial", :locals => { :name => "Josh" })
-  end
-
-  # TODO: The reason for this test is unclear, improve documentation
-  def test_render_missing_xml_partial_and_raise_missing_template
-    @view.formats = [:xml]
-    assert_raises(ActionView::MissingTemplate) { @view.render(:partial => "test/layout_for_partial") }
-  ensure
-    @view.formats = nil
-  end
-
-  def test_render_layout_with_block_and_other_partial_inside
-    render = @view.render(:layout => "test/layout_with_partial_and_yield") { "Yield!" }
-    assert_equal "Before\npartial html\nYield!\nAfter\n", render
-  end
-
-  def test_render_inline
-    assert_equal "Hello, World!", @view.render(:inline => "Hello, World!")
-  end
-
-  def test_render_inline_with_locals
-    assert_equal "Hello, Josh!", @view.render(:inline => "Hello, <%= name %>!", :locals => { :name => "Josh" })
-  end
-
-  def test_render_fallbacks_to_erb_for_unknown_types
-    assert_equal "Hello, World!", @view.render(:inline => "Hello, World!", :type => :bar)
-  end
-
-  CustomHandler = lambda do |template|
-    "@output_buffer = ''\n" +
-      "@output_buffer << 'source: #{template.source.inspect}'\n"
-  end
-
-  def test_render_inline_with_render_from_to_proc
-    ActionView::Template.register_template_handler :ruby_handler, :source.to_proc
-    assert_equal '3', @view.render(:inline => "(1 + 2).to_s", :type => :ruby_handler)
-  end
-
-  def test_render_inline_with_compilable_custom_type
-    ActionView::Template.register_template_handler :foo, CustomHandler
-    assert_equal 'source: "Hello, World!"', @view.render(:inline => "Hello, World!", :type => :foo)
-  end
-
-  def test_render_inline_with_locals_and_compilable_custom_type
-    ActionView::Template.register_template_handler :foo, CustomHandler
-    assert_equal 'source: "Hello, <%= name %>!"', @view.render(:inline => "Hello, <%= name %>!", :locals => { :name => "Josh" }, :type => :foo)
-  end
-
-  def test_render_knows_about_types_registered_when_extensions_are_checked_earlier_in_initialization
-    ActionView::Template::Handlers.extensions
-    ActionView::Template.register_template_handler :foo, CustomHandler
-    assert ActionView::Template::Handlers.extensions.include?(:foo)
-  end
-
-  def test_render_ignores_templates_with_malformed_template_handlers
-    ActiveSupport::Deprecation.silence do
-      %w(malformed malformed.erb malformed.html.erb malformed.en.html.erb).each do |name|
-        assert_raises(ActionView::MissingTemplate) { @view.render(:file => "test/malformed/#{name}") }
-      end
-    end
-  end
-
-  def test_render_with_layout
-    assert_equal %(<title></title>\nHello world!\n),
-      @view.render(:file => "test/hello_world", :layout => "layouts/yield")
-  end
-
-  def test_render_with_layout_which_has_render_inline
-    assert_equal %(welcome\nHello world!\n),
-      @view.render(:file => "test/hello_world", :layout => "layouts/yield_with_render_inline_inside")
-  end
-
-  def test_render_with_layout_which_renders_another_partial
-    assert_equal %(partial html\nHello world!\n),
-      @view.render(:file => "test/hello_world", :layout => "layouts/yield_with_render_partial_inside")
-  end
-
-  def test_render_layout_with_block_and_yield
-    assert_equal %(Content from block!\n),
-      @view.render(:layout => "layouts/yield_only") { "Content from block!" }
-  end
-
-  def test_render_layout_with_block_and_yield_with_params
-    assert_equal %(Yield! Content from block!\n),
-      @view.render(:layout => "layouts/yield_with_params") { |param| "#{param} Content from block!" }
-  end
-
-  def test_render_layout_with_block_which_renders_another_partial_and_yields
-    assert_equal %(partial html\nContent from block!\n),
-      @view.render(:layout => "layouts/partial_and_yield") { "Content from block!" }
-  end
-
-  def test_render_partial_and_layout_without_block_with_locals
-    assert_equal %(Before (Foo!)\npartial html\nAfter),
-      @view.render(:partial => 'test/partial', :layout => 'test/layout_for_partial', :locals => { :name => 'Foo!'})
-  end
-
-  def test_render_partial_and_layout_without_block_with_locals_and_rendering_another_partial
-    assert_equal %(Before (Foo!)\npartial html\npartial with partial\n\nAfter),
-      @view.render(:partial => 'test/partial_with_partial', :layout => 'test/layout_for_partial', :locals => { :name => 'Foo!'})
-  end
-
-  def test_render_layout_with_a_nested_render_layout_call
-    assert_equal %(Before (Foo!)\nBefore (Bar!)\npartial html\nAfter\npartial with layout\n\nAfter),
-      @view.render(:partial => 'test/partial_with_layout', :layout => 'test/layout_for_partial', :locals => { :name => 'Foo!'})
-  end
-
-  def test_render_layout_with_a_nested_render_layout_call_using_block_with_render_partial
-    assert_equal %(Before (Foo!)\nBefore (Bar!)\n\n  partial html\n\nAfterpartial with layout\n\nAfter),
-      @view.render(:partial => 'test/partial_with_layout_block_partial', :layout => 'test/layout_for_partial', :locals => { :name => 'Foo!'})
-  end
-
-  def test_render_layout_with_a_nested_render_layout_call_using_block_with_render_content
-    assert_equal %(Before (Foo!)\nBefore (Bar!)\n\n  Content from inside layout!\n\nAfterpartial with layout\n\nAfter),
-      @view.render(:partial => 'test/partial_with_layout_block_content', :layout => 'test/layout_for_partial', :locals => { :name => 'Foo!'})
-  end
-
-  def test_render_partial_with_layout_raises_descriptive_error
-    e = assert_raises(ActionView::MissingTemplate) { @view.render(partial: 'test/partial', layout: true) }
-    assert_match "Missing partial /true with", e.message
-  end
-
-  def test_render_with_nested_layout
-    assert_equal %(<title>title</title>\n\n<div id="column">column</div>\n<div id="content">content</div>\n),
-      @view.render(:file => "test/nested_layout", :layout => "layouts/yield")
-  end
-
-  def test_render_with_file_in_layout
-    assert_equal %(\n<title>title</title>\n\n),
-      @view.render(:file => "test/layout_render_file")
-  end
-
-  def test_render_layout_with_object
-    assert_equal %(<title>David</title>),
-      @view.render(:file => "test/layout_render_object")
-  end
-
-  def test_render_with_passing_couple_extensions_to_one_register_template_handler_function_call
-    ActionView::Template.register_template_handler :foo1, :foo2, CustomHandler
-    assert_equal @view.render(:inline => "Hello, World!", :type => :foo1), @view.render(:inline => "Hello, World!", :type => :foo2)
-  end
-
-  def test_render_throws_exception_when_no_extensions_passed_to_register_template_handler_function_call
-    assert_raises(ArgumentError) { ActionView::Template.register_template_handler CustomHandler }
-  end
-end
-
-class CachedViewRenderTest < ActiveSupport::TestCase
-  include RenderTestCases
-
-  # Ensure view path cache is primed
-  def setup
-    view_paths = ActionController::Base.view_paths
-    assert_equal ActionView::OptimizedFileSystemResolver, view_paths.first.class
-    setup_view(view_paths)
-  end
-
-  def teardown
-    GC.start
-  end
-end
-
-class LazyViewRenderTest < ActiveSupport::TestCase
-  include RenderTestCases
-
-  # Test the same thing as above, but make sure the view path
-  # is not eager loaded
-  def setup
-    path = ActionView::FileSystemResolver.new(FIXTURE_LOAD_PATH)
-    view_paths = ActionView::PathSet.new([path])
-    assert_equal ActionView::FileSystemResolver.new(FIXTURE_LOAD_PATH), view_paths.first
-    setup_view(view_paths)
-  end
-
-  def teardown
-    GC.start
-  end
-
-  def test_render_utf8_template_with_magic_comment
-    with_external_encoding Encoding::ASCII_8BIT do
-      result = @view.render(:file => "test/utf8_magic", :formats => [:html], :layouts => "layouts/yield")
-      assert_equal Encoding::UTF_8, result.encoding
-      assert_equal "\nРусский \nтекст\n\nUTF-8\nUTF-8\nUTF-8\n", result
-    end
-  end
-
-  def test_render_utf8_template_with_default_external_encoding
-    with_external_encoding Encoding::UTF_8 do
-      result = @view.render(:file => "test/utf8", :formats => [:html], :layouts => "layouts/yield")
-      assert_equal Encoding::UTF_8, result.encoding
-      assert_equal "Русский текст\n\nUTF-8\nUTF-8\nUTF-8\n", result
-    end
-  end
-
-  def test_render_utf8_template_with_incompatible_external_encoding
-    with_external_encoding Encoding::SHIFT_JIS do
-      e = assert_raises(ActionView::Template::Error) { @view.render(:file => "test/utf8", :formats => [:html], :layouts => "layouts/yield") }
-      assert_match 'Your template was not saved as valid Shift_JIS', e.original_exception.message
-    end
-  end
-
-  def test_render_utf8_template_with_partial_with_incompatible_encoding
-    with_external_encoding Encoding::SHIFT_JIS do
-      e = assert_raises(ActionView::Template::Error) { @view.render(:file => "test/utf8_magic_with_bare_partial", :formats => [:html], :layouts => "layouts/yield") }
-      assert_match 'Your template was not saved as valid Shift_JIS', e.original_exception.message
-    end
-  end
-
-  def with_external_encoding(encoding)
-    old = Encoding.default_external
-    silence_warnings { Encoding.default_external = encoding }
-    yield
-  ensure
-    silence_warnings { Encoding.default_external = old }
-  end
-end
diff --git a/actionpack/test/template/resolver_patterns_test.rb b/actionpack/test/template/resolver_patterns_test.rb
deleted file mode 100644
index 97b1bad055..0000000000
--- a/actionpack/test/template/resolver_patterns_test.rb
+++ /dev/null
@@ -1,31 +0,0 @@
-require 'abstract_unit'
-
-class ResolverPatternsTest < ActiveSupport::TestCase
-  def setup
-    path = File.expand_path("../../fixtures/", __FILE__)
-    pattern = ":prefix/{:formats/,}:action{.:formats,}{.:handlers,}"
-    @resolver = ActionView::FileSystemResolver.new(path, pattern)
-  end
-
-  def test_should_return_empty_list_for_unknown_path
-    templates = @resolver.find_all("unknown", "custom_pattern", false, {:locale => [], :formats => [:html], :handlers => [:erb]})
-    assert_equal [], templates, "expected an empty list of templates"
-  end
-
-  def test_should_return_template_for_declared_path
-    templates = @resolver.find_all("path", "custom_pattern", false, {:locale => [], :formats => [:html], :handlers => [:erb]})
-    assert_equal 1, templates.size, "expected one template"
-    assert_equal "Hello custom patterns!", templates.first.source
-    assert_equal "custom_pattern/path",    templates.first.virtual_path
-    assert_equal [:html],                  templates.first.formats
-  end
-
-  def test_should_return_all_templates_when_ambigous_pattern
-    templates = @resolver.find_all("another", "custom_pattern", false, {:locale => [], :formats => [:html], :handlers => [:erb]})
-    assert_equal 2, templates.size, "expected two templates"
-    assert_equal "Another template!",      templates[0].source
-    assert_equal "custom_pattern/another", templates[0].virtual_path
-    assert_equal "Hello custom patterns!", templates[1].source
-    assert_equal "custom_pattern/another", templates[1].virtual_path
-  end
-end
diff --git a/actionpack/test/template/sanitize_helper_test.rb b/actionpack/test/template/sanitize_helper_test.rb
deleted file mode 100644
index 12d5260a9d..0000000000
--- a/actionpack/test/template/sanitize_helper_test.rb
+++ /dev/null
@@ -1,51 +0,0 @@
-require 'abstract_unit'
-
-# The exhaustive tests are in test/controller/html/sanitizer_test.rb.
-# This tests the that the helpers hook up correctly to the sanitizer classes.
-class SanitizeHelperTest < ActionView::TestCase
-  tests ActionView::Helpers::SanitizeHelper
-
-  def test_strip_links
-    assert_equal "Dont touch me", strip_links("Dont touch me")
-    assert_equal "<a<a", strip_links("<a<a")
-    assert_equal "on my mind\nall day long", strip_links("<a href='almost'>on my mind</a>\n<A href='almost'>all day long</A>")
-    assert_equal "0wn3d", strip_links("<a href='http://www.rubyonrails.com/'><a href='http://www.rubyonrails.com/' onlclick='steal()'>0wn3d</a></a>")
-    assert_equal "Magic", strip_links("<a href='http://www.rubyonrails.com/'>Mag<a href='http://www.ruby-lang.org/'>ic")
-    assert_equal "FrrFox", strip_links("<href onlclick='steal()'>FrrFox</a></href>")
-    assert_equal "My mind\nall <b>day</b> long", strip_links("<a href='almost'>My mind</a>\n<A href='almost'>all <b>day</b> long</A>")
-    assert_equal "all <b>day</b> long", strip_links("<<a>a href='hello'>all <b>day</b> long<</A>/a>")
-  end
-
-  def test_sanitize_form
-    assert_equal '', sanitize("<form action=\"/foo/bar\" method=\"post\"><input></form>")
-  end
-
-  def test_should_sanitize_illegal_style_properties
-    raw      = %(display:block; position:absolute; left:0; top:0; width:100%; height:100%; z-index:1; background-color:black; background-image:url(http://www.ragingplatypus.com/i/cam-full.jpg); background-x:center; background-y:center; background-repeat:repeat;)
-    expected = %(display: block; width: 100%; height: 100%; background-color: black; background-image: ; background-x: center; background-y: center;)
-    assert_equal expected, sanitize_css(raw)
-  end
-
-  def test_strip_tags
-    assert_equal("<<<bad html", strip_tags("<<<bad html"))
-    assert_equal("<<", strip_tags("<<<bad html>"))
-    assert_equal("Dont touch me", strip_tags("Dont touch me"))
-    assert_equal("This is a test.", strip_tags("<p>This <u>is<u> a <a href='test.html'><strong>test</strong></a>.</p>"))
-    assert_equal("Weirdos", strip_tags("Wei<<a>a onclick='alert(document.cookie);'</a>/>rdos"))
-    assert_equal("This is a test.", strip_tags("This is a test."))
-    assert_equal(
-    %{This is a test.\n\n\nIt no longer contains any HTML.\n}, strip_tags(
-    %{<title>This is <b>a <a href="" target="_blank">test</a></b>.</title>\n\n<!-- it has a comment -->\n\n<p>It no <b>longer <strong>contains <em>any <strike>HTML</strike></em>.</strong></b></p>\n}))
-    assert_equal "This has a  here.", strip_tags("This has a <!-- comment --> here.")
-    [nil, '', '   '].each do |blank|
-      stripped = strip_tags(blank)
-      assert_equal blank, stripped
-    end
-    assert_equal "", strip_tags("<script>")
-    assert_equal "something &lt;img onerror=alert(1337)", ERB::Util.html_escape(strip_tags("something <img onerror=alert(1337)"))
-  end
-
-  def test_sanitize_is_marked_safe
-    assert sanitize("<html><script></script></html>").html_safe?
-  end
-end
diff --git a/actionpack/test/template/streaming_render_test.rb b/actionpack/test/template/streaming_render_test.rb
deleted file mode 100644
index 520bf3a824..0000000000
--- a/actionpack/test/template/streaming_render_test.rb
+++ /dev/null
@@ -1,109 +0,0 @@
-# encoding: utf-8
-require 'abstract_unit'
-require 'controller/fake_models'
-
-class TestController < ActionController::Base
-end
-
-class FiberedTest < ActiveSupport::TestCase
-  def setup
-    view_paths = ActionController::Base.view_paths
-    @assigns = { :secret => 'in the sauce', :name => nil }
-    @view = ActionView::Base.new(view_paths, @assigns)
-    @controller_view = TestController.new.view_context
-  end
-
-  def render_body(options)
-    @view.view_renderer.render_body(@view, options)
-  end
-
-  def buffered_render(options)
-    body = render_body(options)
-    string = ""
-    body.each do |piece|
-      string << piece
-    end
-    string
-  end
-
-  def test_streaming_works
-    content = []
-    body = render_body(:template => "test/hello_world", :layout => "layouts/yield")
-
-    body.each do |piece|
-      content << piece
-    end
-
-    assert_equal "<title>",      content[0]
-    assert_equal "",             content[1]
-    assert_equal "</title>\n",   content[2]
-    assert_equal "Hello world!", content[3]
-    assert_equal "\n",           content[4]
-  end
-
-  def test_render_file
-    assert_equal "Hello world!", buffered_render(:file => "test/hello_world")
-  end
-
-  def test_render_file_with_locals
-    locals = { :secret => 'in the sauce' }
-    assert_equal "The secret is in the sauce\n", buffered_render(:file => "test/render_file_with_locals", :locals => locals)
-  end
-
-  def test_render_partial
-    assert_equal "only partial", buffered_render(:partial => "test/partial_only")
-  end
-
-  def test_render_inline
-    assert_equal "Hello, World!", buffered_render(:inline => "Hello, World!")
-  end
-
-  def test_render_without_layout
-    assert_equal "Hello world!", buffered_render(:template => "test/hello_world")
-  end
-
-  def test_render_with_layout
-    assert_equal %(<title></title>\nHello world!\n),
-      buffered_render(:template => "test/hello_world", :layout => "layouts/yield")
-  end
-
-  def test_render_with_layout_which_has_render_inline
-    assert_equal %(welcome\nHello world!\n),
-      buffered_render(:template => "test/hello_world", :layout => "layouts/yield_with_render_inline_inside")
-  end
-
-  def test_render_with_layout_which_renders_another_partial
-    assert_equal %(partial html\nHello world!\n),
-      buffered_render(:template => "test/hello_world", :layout => "layouts/yield_with_render_partial_inside")
-  end
-
-  def test_render_with_nested_layout
-    assert_equal %(<title>title</title>\n\n<div id="column">column</div>\n<div id="content">content</div>\n),
-      buffered_render(:template => "test/nested_layout", :layout => "layouts/yield")
-  end
-
-  def test_render_with_file_in_layout
-    assert_equal %(\n<title>title</title>\n\n),
-      buffered_render(:template => "test/layout_render_file")
-  end
-
-  def test_render_with_handler_without_streaming_support
-    assert_match "<p>This is grand!</p>", buffered_render(:template => "test/hello")
-  end
-
-  def test_render_with_streaming_multiple_yields_provide_and_content_for
-    assert_equal "Yes, \nthis works\n like a charm.",
-      buffered_render(:template => "test/streaming", :layout => "layouts/streaming")
-  end
-
-  def test_render_with_streaming_with_fake_yields_and_streaming_buster
-    assert_equal "This won't look\n good.",
-      buffered_render(:template => "test/streaming_buster", :layout => "layouts/streaming")
-  end
-
-  def test_render_with_nested_streaming_multiple_yields_provide_and_content_for
-    assert_equal "?Yes, \n\nthis works\n\n? like a charm.",
-      buffered_render(:template => "test/nested_streaming", :layout => "layouts/streaming")
-  end
-
-end
diff --git a/actionpack/test/template/tag_helper_test.rb b/actionpack/test/template/tag_helper_test.rb
deleted file mode 100644
index 9e711c6529..0000000000
--- a/actionpack/test/template/tag_helper_test.rb
+++ /dev/null
@@ -1,130 +0,0 @@
-require 'abstract_unit'
-
-class TagHelperTest < ActionView::TestCase
-  include RenderERBUtils
-
-  tests ActionView::Helpers::TagHelper
-
-  def test_tag
-    assert_equal "<br />", tag("br")
-    assert_equal "<br clear=\"left\" />", tag(:br, :clear => "left")
-    assert_equal "<br>", tag("br", nil, true)
-  end
-
-  def test_tag_options
-    str = tag("p", "class" => "show", :class => "elsewhere")
-    assert_match(/class="show"/, str)
-    assert_match(/class="elsewhere"/, str)
-  end
-
-  def test_tag_options_rejects_nil_option
-    assert_equal "<p />", tag("p", :ignored => nil)
-  end
-
-  def test_tag_options_accepts_false_option
-    assert_equal "<p value=\"false\" />", tag("p", :value => false)
-  end
-
-  def test_tag_options_accepts_blank_option
-    assert_equal "<p included=\"\" />", tag("p", :included => '')
-  end
-
-  def test_tag_options_converts_boolean_option
-    assert_equal '<p disabled="disabled" itemscope="itemscope" multiple="multiple" readonly="readonly" />',
-      tag("p", :disabled => true, :itemscope => true, :multiple => true, :readonly => true)
-  end
-
-  def test_content_tag
-    assert_equal "<a href=\"create\">Create</a>", content_tag("a", "Create", "href" => "create")
-    assert content_tag("a", "Create", "href" => "create").html_safe?
-    assert_equal content_tag("a", "Create", "href" => "create"),
-                 content_tag("a", "Create", :href => "create")
-    assert_equal "<p>&lt;script&gt;evil_js&lt;/script&gt;</p>",
-                 content_tag(:p, '<script>evil_js</script>')
-    assert_equal "<p><script>evil_js</script></p>",
-                 content_tag(:p, '<script>evil_js</script>', nil, false)
-  end
-
-  def test_content_tag_with_block_in_erb
-    buffer = render_erb("<%= content_tag(:div) do %>Hello world!<% end %>")
-    assert_dom_equal "<div>Hello world!</div>", buffer
-  end
-
-  def test_content_tag_with_block_and_options_in_erb
-    buffer = render_erb("<%= content_tag(:div, :class => 'green') do %>Hello world!<% end %>")
-    assert_dom_equal %(<div class="green">Hello world!</div>), buffer
-  end
-
-  def test_content_tag_with_block_and_options_out_of_erb
-    assert_dom_equal %(<div class="green">Hello world!</div>), content_tag(:div, :class => "green") { "Hello world!" }
-  end
-
-  def test_content_tag_with_block_and_options_outside_out_of_erb
-    assert_equal content_tag("a", "Create", :href => "create"),
-                 content_tag("a", "href" => "create") { "Create" }
-  end
-
-  def test_content_tag_nested_in_content_tag_out_of_erb
-    assert_equal content_tag("p", content_tag("b", "Hello")),
-                 content_tag("p") { content_tag("b", "Hello") },
-                 output_buffer
-  end
-
-  def test_content_tag_nested_in_content_tag_in_erb
-    assert_equal "<p>\n  <b>Hello</b>\n</p>", view.render("test/content_tag_nested_in_content_tag")
-  end
-
-  def test_content_tag_with_escaped_array_class
-    str = content_tag('p', "limelight", :class => ["song", "play>"])
-    assert_equal "<p class=\"song play&gt;\">limelight</p>", str
-
-    str = content_tag('p', "limelight", :class => ["song", "play"])
-    assert_equal "<p class=\"song play\">limelight</p>", str
-  end
-
-  def test_content_tag_with_unescaped_array_class
-    str = content_tag('p', "limelight", {:class => ["song", "play>"]}, false)
-    assert_equal "<p class=\"song play>\">limelight</p>", str
-  end
-
-  def test_content_tag_with_data_attributes
-    assert_dom_equal '<p data-number="1" data-string="hello" data-string-with-quotes="double&quot;quote&quot;party&quot;">limelight</p>',
-      content_tag('p', "limelight", data: { number: 1, string: 'hello', string_with_quotes: 'double"quote"party"' })
-  end
-
-  def test_cdata_section
-    assert_equal "<![CDATA[<hello world>]]>", cdata_section("<hello world>")
-  end
-
-  def test_cdata_section_splitted
-    assert_equal "<![CDATA[hello]]]]><![CDATA[>world]]>", cdata_section("hello]]>world")
-    assert_equal "<![CDATA[hello]]]]><![CDATA[>world]]]]><![CDATA[>again]]>", cdata_section("hello]]>world]]>again")
-  end
-
-  def test_escape_once
-    assert_equal '1 &lt; 2 &amp; 3', escape_once('1 < 2 &amp; 3')
-  end
-
-  def test_tag_honors_html_safe_for_param_values
-    ['1&amp;2', '1 &lt; 2', '&#8220;test&#8220;'].each do |escaped|
-      assert_equal %(<a href="#{escaped}" />), tag('a', :href => escaped.html_safe)
-    end
-  end
-
-  def test_skip_invalid_escaped_attributes
-    ['&1;', '&#1dfa3;', '& #123;'].each do |escaped|
-      assert_equal %(<a href="#{escaped.gsub(/&/, '&amp;')}" />), tag('a', :href => escaped)
-    end
-  end
-
-  def test_disable_escaping
-    assert_equal '<a href="&amp;" />', tag('a', { :href => '&amp;' }, false, false)
-  end
-
-  def test_data_attributes
-    ['data', :data].each { |data|
-      assert_dom_equal '<a data-a-float="3.14" data-a-big-decimal="-123.456" data-a-number="1" data-array="[1,2,3]" data-hash="{&quot;key&quot;:&quot;value&quot;}" data-string-with-quotes="double&quot;quote&quot;party&quot;" data-string="hello" data-symbol="foo" />',
-        tag('a', { data => { a_float: 3.14, a_big_decimal: BigDecimal.new("-123.456"), a_number: 1, string: 'hello', symbol: :foo, array: [1, 2, 3], hash: { key: 'value'}, string_with_quotes: 'double"quote"party"' } })
-    }
-  end
-end
diff --git a/actionpack/test/template/template_error_test.rb b/actionpack/test/template/template_error_test.rb
deleted file mode 100644
index 91424daeed..0000000000
--- a/actionpack/test/template/template_error_test.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-require "abstract_unit"
-
-class TemplateErrorTest < ActiveSupport::TestCase
-  def test_provides_original_message
-    error = ActionView::Template::Error.new("test", Exception.new("original"))
-    assert_equal "original", error.message
-  end
-
-  def test_provides_useful_inspect
-    error = ActionView::Template::Error.new("test", Exception.new("original"))
-    assert_equal "#<ActionView::Template::Error: original>", error.inspect
-  end
-end
diff --git a/actionpack/test/template/template_test.rb b/actionpack/test/template/template_test.rb
deleted file mode 100644
index 8d32205fb8..0000000000
--- a/actionpack/test/template/template_test.rb
+++ /dev/null
@@ -1,207 +0,0 @@
-# encoding: US-ASCII
-require "abstract_unit"
-require "logger"
-
-class TestERBTemplate < ActiveSupport::TestCase
-  ERBHandler = ActionView::Template::Handlers::ERB.new
-
-  class LookupContext
-    def disable_cache
-      yield
-    end
-
-    def find_template(*args)
-    end
-
-    attr_accessor :formats
-  end
-
-  class Context
-    def initialize
-      @output_buffer = "original"
-      @virtual_path = nil
-    end
-
-    def hello
-      "Hello"
-    end
-
-    def apostrophe
-      "l'apostrophe"
-    end
-
-    def partial
-      ActionView::Template.new(
-        "<%= @virtual_path %>",
-        "partial",
-        ERBHandler,
-        :virtual_path => "partial"
-      )
-    end
-
-    def lookup_context
-      @lookup_context ||= LookupContext.new
-    end
-
-    def logger
-      ActiveSupport::Logger.new(STDERR)
-    end
-
-    def my_buffer
-      @output_buffer
-    end
-  end
-
-  def new_template(body = "<%= hello %>", details = { format: :html })
-    ActionView::Template.new(body, "hello template", details.fetch(:handler) { ERBHandler }, {:virtual_path => "hello"}.merge!(details))
-  end
-
-  def render(locals = {})
-    @template.render(@context, locals)
-  end
-
-  def setup
-    @context = Context.new
-  end
-
-  def test_mime_type_is_deprecated
-    template = new_template
-    assert_deprecated 'Template#mime_type is deprecated and will be removed' do
-      template.mime_type
-    end
-  end
-
-  def test_basic_template
-    @template = new_template
-    assert_equal "Hello", render
-  end
-
-  def test_basic_template_does_html_escape
-    @template = new_template("<%= apostrophe %>")
-    assert_equal "l&#39;apostrophe", render
-  end
-
-  def test_text_template_does_not_html_escape
-    @template = new_template("<%= apostrophe %> <%== apostrophe %>", format: :text)
-    assert_equal "l'apostrophe l'apostrophe", render
-  end
-
-  def test_raw_template
-    @template = new_template("<%= hello %>", :handler => ActionView::Template::Handlers::Raw.new)
-    assert_equal "<%= hello %>", render
-  end
-
-  def test_template_loses_its_source_after_rendering
-    @template = new_template
-    render
-    assert_nil @template.source
-  end
-
-  def test_template_does_not_lose_its_source_after_rendering_if_it_does_not_have_a_virtual_path
-    @template = new_template("Hello", :virtual_path => nil)
-    render
-    assert_equal "Hello", @template.source
-  end
-
-  def test_locals
-    @template = new_template("<%= my_local %>")
-    @template.locals = [:my_local]
-    assert_equal "I am a local", render(:my_local => "I am a local")
-  end
-
-  def test_restores_buffer
-    @template = new_template
-    assert_equal "Hello", render
-    assert_equal "original", @context.my_buffer
-  end
-
-  def test_virtual_path
-    @template = new_template("<%= @virtual_path %>" \
-                             "<%= partial.render(self, {}) %>" \
-                             "<%= @virtual_path %>")
-    assert_equal "hellopartialhello", render
-  end
-
-  def test_refresh_with_templates
-    @template = new_template("Hello", :virtual_path => "test/foo/bar")
-    @template.locals = [:key]
-    @context.lookup_context.expects(:find_template).with("bar", %w(test/foo), false, [:key]).returns("template")
-    assert_equal "template", @template.refresh(@context)
-  end
-
-  def test_refresh_with_partials
-    @template = new_template("Hello", :virtual_path => "test/_foo")
-    @template.locals = [:key]
-    @context.lookup_context.expects(:find_template).with("foo", %w(test), true, [:key]).returns("partial")
-    assert_equal "partial", @template.refresh(@context)
-  end
-
-  def test_refresh_raises_an_error_without_virtual_path
-    @template = new_template("Hello", :virtual_path => nil)
-    assert_raise RuntimeError do
-      @template.refresh(@context)
-    end
-  end
-
-  def test_resulting_string_is_utf8
-    @template = new_template
-    assert_equal Encoding::UTF_8, render.encoding
-  end
-
-  def test_no_magic_comment_word_with_utf_8
-    @template = new_template("hello \u{fc}mlat")
-    assert_equal Encoding::UTF_8, render.encoding
-    assert_equal "hello \u{fc}mlat", render
-  end
-
-  # This test ensures that if the default_external
-  # is set to something other than UTF-8, we don't
-  # get any errors and get back a UTF-8 String.
-  def test_default_external_works
-    with_external_encoding "ISO-8859-1" do
-      @template = new_template("hello \xFCmlat")
-      assert_equal Encoding::UTF_8, render.encoding
-      assert_equal "hello \u{fc}mlat", render
-    end
-  end
-
-  def test_encoding_can_be_specified_with_magic_comment
-    @template = new_template("# encoding: ISO-8859-1\nhello \xFCmlat")
-    assert_equal Encoding::UTF_8, render.encoding
-    assert_equal "\nhello \u{fc}mlat", render
-  end
-
-  # TODO: This is currently handled inside ERB. The case of explicitly
-  # lying about encodings via the normal Rails API should be handled
-  # inside Rails.
-  def test_lying_with_magic_comment
-    assert_raises(ActionView::Template::Error) do
-      @template = new_template("# encoding: UTF-8\nhello \xFCmlat", :virtual_path => nil)
-      render
-    end
-  end
-
-  def test_encoding_can_be_specified_with_magic_comment_in_erb
-    with_external_encoding Encoding::UTF_8 do
-      @template = new_template("<%# encoding: ISO-8859-1 %>hello \xFCmlat", :virtual_path => nil)
-      assert_equal Encoding::UTF_8, render.encoding
-      assert_equal "hello \u{fc}mlat", render
-    end
-  end
-
-  def test_error_when_template_isnt_valid_utf8
-    assert_raises(ActionView::Template::Error, /\xFC/) do
-      @template = new_template("hello \xFCmlat", :virtual_path => nil)
-      render
-    end
-  end
-
-  def with_external_encoding(encoding)
-    old = Encoding.default_external
-    Encoding::Converter.new old, encoding if old != encoding
-    silence_warnings { Encoding.default_external = encoding }
-    yield
-  ensure
-    silence_warnings { Encoding.default_external = old }
-  end
-end
diff --git a/actionpack/test/template/test_case_test.rb b/actionpack/test/template/test_case_test.rb
deleted file mode 100644
index acd002ce73..0000000000
--- a/actionpack/test/template/test_case_test.rb
+++ /dev/null
@@ -1,367 +0,0 @@
-require 'abstract_unit'
-require 'controller/fake_controllers'
-
-module ActionView
-
-  module ATestHelper
-  end
-
-  module AnotherTestHelper
-    def from_another_helper
-      'Howdy!'
-    end
-  end
-
-  module ASharedTestHelper
-    def from_shared_helper
-      'Holla!'
-    end
-  end
-
-  class TestCase
-    helper ASharedTestHelper
-
-    module SharedTests
-      def self.included(test_case)
-        test_case.class_eval do
-          test "helpers defined on ActionView::TestCase are available" do
-            assert test_case.ancestors.include?(ASharedTestHelper)
-            assert_equal 'Holla!', from_shared_helper
-          end
-        end
-      end
-    end
-  end
-
-  class GeneralViewTest < ActionView::TestCase
-    include SharedTests
-    test_case = self
-
-    test "memoizes the view" do
-      assert_same view, view
-    end
-
-    test "exposes view as _view for backwards compatibility" do
-      assert_same _view, view
-    end
-
-    test "retrieve non existing config values" do
-      assert_equal nil, ActionView::Base.new.config.something_odd
-    end
-
-    test "works without testing a helper module" do
-      assert_equal 'Eloy', render('developers/developer', :developer => stub(:name => 'Eloy'))
-    end
-
-    test "can render a layout with block" do
-      assert_equal "Before (ChrisCruft)\n!\nAfter",
-                    render(:layout => "test/layout_for_partial", :locals => {:name => "ChrisCruft"}) {"!"}
-    end
-
-    helper AnotherTestHelper
-    test "additional helper classes can be specified as in a controller" do
-      assert test_case.ancestors.include?(AnotherTestHelper)
-      assert_equal 'Howdy!', from_another_helper
-    end
-
-    test "determine_default_helper_class returns nil if the test name constant resolves to a class" do
-      assert_nil self.class.determine_default_helper_class("String")
-    end
-
-    test "delegates notice to request.flash[:notice]" do
-      view.request.flash.expects(:[]).with(:notice)
-      view.notice
-    end
-
-    test "delegates alert to request.flash[:alert]" do
-      view.request.flash.expects(:[]).with(:alert)
-      view.alert
-    end
-
-    test "uses controller lookup context" do
-      assert_equal self.lookup_context, @controller.lookup_context
-    end
-  end
-
-  class ClassMethodsTest < ActionView::TestCase
-    include SharedTests
-    test_case = self
-
-    tests ATestHelper
-    test "tests the specified helper module" do
-      assert_equal ATestHelper, test_case.helper_class
-      assert test_case.ancestors.include?(ATestHelper)
-    end
-
-    helper AnotherTestHelper
-    test "additional helper classes can be specified as in a controller" do
-      assert test_case.ancestors.include?(AnotherTestHelper)
-      assert_equal 'Howdy!', from_another_helper
-
-      test_case.helper_class.module_eval do
-        def render_from_helper
-          from_another_helper
-        end
-      end
-      assert_equal 'Howdy!', render(:partial => 'test/from_helper')
-    end
-  end
-
-  class HelperInclusionTest < ActionView::TestCase
-    module RenderHelper
-      def render_from_helper
-        render :partial => 'customer', :collection => @customers
-      end
-    end
-
-    helper RenderHelper
-
-    test "helper class that is being tested is always included in view instance" do
-      @controller.controller_path = 'test'
-
-      @customers = [stub(:name => 'Eloy'), stub(:name => 'Manfred')]
-      assert_match(/Hello: EloyHello: Manfred/, render(:partial => 'test/from_helper'))
-    end
-  end
-
-  class ControllerHelperMethod < ActionView::TestCase
-    module SomeHelper
-      def some_method
-        render :partial => 'test/from_helper'
-      end
-    end
-
-    helper SomeHelper
-
-    test "can call a helper method defined on the current controller from a helper" do
-      @controller.singleton_class.class_eval <<-EOF, __FILE__, __LINE__ + 1
-        def render_from_helper
-          'controller_helper_method'
-        end
-      EOF
-      @controller.class.helper_method :render_from_helper
-
-      assert_equal 'controller_helper_method', some_method
-    end
-  end
-
-  class ViewAssignsTest < ActionView::TestCase
-    test "view_assigns returns a Hash of user defined ivars" do
-      @a = 'b'
-      @c = 'd'
-      assert_equal({:a => 'b', :c => 'd'}, view_assigns)
-    end
-
-    test "view_assigns excludes internal ivars" do
-      INTERNAL_IVARS.each do |ivar|
-        assert defined?(ivar), "expected #{ivar} to be defined"
-        assert !view_assigns.keys.include?(ivar.to_s.sub('@', '').to_sym), "expected #{ivar} to be excluded from view_assigns"
-      end
-    end
-  end
-
-  class HelperExposureTest < ActionView::TestCase
-    helper(Module.new do
-      def render_from_helper
-        from_test_case
-      end
-    end)
-    test "is able to make methods available to the view" do
-      assert_equal 'Word!', render(:partial => 'test/from_helper')
-    end
-
-    def from_test_case; 'Word!'; end
-    helper_method :from_test_case
-  end
-
-  class IgnoreProtectAgainstForgeryTest < ActionView::TestCase
-    module HelperThatInvokesProtectAgainstForgery
-      def help_me
-        protect_against_forgery?
-      end
-    end
-
-    helper HelperThatInvokesProtectAgainstForgery
-
-    test "protect_from_forgery? in any helpers returns false" do
-      assert !view.help_me
-    end
-
-  end
-
-  class ATestHelperTest < ActionView::TestCase
-    include SharedTests
-    test_case = self
-
-    test "inflects the name of the helper module to test from the test case class" do
-      assert_equal ATestHelper, test_case.helper_class
-      assert test_case.ancestors.include?(ATestHelper)
-    end
-
-    test "a configured test controller is available" do
-      assert_kind_of ActionController::Base, controller
-      assert_equal '', controller.controller_path
-    end
-
-    test "no additional helpers should shared across test cases" do
-      assert !test_case.ancestors.include?(AnotherTestHelper)
-      assert_raise(NoMethodError) { send :from_another_helper }
-    end
-
-    test "is able to use routes" do
-      controller.request.assign_parameters(@routes, 'foo', 'index')
-      assert_equal '/foo', url_for
-      assert_equal '/bar', url_for(:controller => 'bar')
-    end
-
-    test "is able to use named routes" do
-      with_routing do |set|
-        set.draw { resources :contents }
-        assert_equal 'http://test.host/contents/new', new_content_url
-        assert_equal 'http://test.host/contents/1',   content_url(:id => 1)
-      end
-    end
-
-    test "is able to use mounted routes" do
-      with_routing do |set|
-        app = Class.new do
-          def self.routes
-            @routes ||= ActionDispatch::Routing::RouteSet.new
-          end
-
-          routes.draw { get "bar", :to => lambda {} }
-
-          def self.call(*)
-          end
-        end
-
-        set.draw { mount app => "/foo", :as => "foo_app" }
-
-        assert_equal '/foo/bar', foo_app.bar_path
-      end
-    end
-
-    test "named routes can be used from helper included in view" do
-      with_routing do |set|
-        set.draw { resources :contents }
-        _helpers.module_eval do
-          def render_from_helper
-            new_content_url
-          end
-        end
-
-        assert_equal 'http://test.host/contents/new', render(:partial => 'test/from_helper')
-      end
-    end
-
-    test "is able to render partials with local variables" do
-      assert_equal 'Eloy', render('developers/developer', :developer => stub(:name => 'Eloy'))
-      assert_equal 'Eloy', render(:partial => 'developers/developer',
-                                  :locals => { :developer => stub(:name => 'Eloy') })
-    end
-
-    test "is able to render partials from templates and also use instance variables" do
-      @controller.controller_path = "test"
-
-      @customers = [stub(:name => 'Eloy'), stub(:name => 'Manfred')]
-      assert_match(/Hello: EloyHello: Manfred/, render(:file => 'test/list'))
-    end
-
-    test "is able to render partials from templates and also use instance variables after view has been referenced" do
-      @controller.controller_path = "test"
-
-      view
-
-      @customers = [stub(:name => 'Eloy'), stub(:name => 'Manfred')]
-      assert_match(/Hello: EloyHello: Manfred/, render(:file => 'test/list'))
-    end
-
-  end
-
-  class AssertionsTest < ActionView::TestCase
-    def render_from_helper
-      form_tag('/foo') do
-        safe_concat render(:text => '<ul><li>foo</li></ul>')
-      end
-    end
-    helper_method :render_from_helper
-
-    test "uses the output_buffer for assert_select" do
-      render(:partial => 'test/from_helper')
-
-      assert_select 'form' do
-        assert_select 'li', :text => 'foo'
-      end
-    end
-  end
-
-  class RenderTemplateTest < ActionView::TestCase
-    test "supports specifying templates with a Regexp" do
-      controller.controller_path = "fun"
-      render(:template => "fun/games/hello_world")
-      assert_template %r{\Afun/games/hello_world\Z}
-    end
-
-    test "supports specifying partials" do
-      controller.controller_path = "test"
-      render(:template => "test/calling_partial_with_layout")
-      assert_template :partial => "_partial_for_use_in_layout"
-    end
-
-    test "supports specifying locals (passing)" do
-      controller.controller_path = "test"
-      render(:template => "test/calling_partial_with_layout")
-      assert_template :partial => "_partial_for_use_in_layout", :locals => { :name => "David" }
-    end
-
-    test "supports specifying locals (failing)" do
-      controller.controller_path = "test"
-      render(:template => "test/calling_partial_with_layout")
-      assert_raise ActiveSupport::TestCase::Assertion, /Somebody else.*David/m do
-        assert_template :partial => "_partial_for_use_in_layout", :locals => { :name => "Somebody Else" }
-      end
-    end
-
-    test 'supports different locals on the same partial' do
-      controller.controller_path = "test"
-      render(:template => "test/render_two_partials")
-      assert_template partial: '_partial', locals: { 'first' => '1' }
-      assert_template partial: '_partial', locals: { 'second' => '2' }
-    end
-
-    test 'raises descriptive error message when template was not rendered' do
-      controller.controller_path = "test"
-      render(template: "test/hello_world_with_partial")
-      e = assert_raise ActiveSupport::TestCase::Assertion do
-        assert_template partial: 'i_was_never_rendered', locals: { 'did_not' => 'happen' }
-      end
-      assert_match "i_was_never_rendered to be rendered but it was not.", e.message
-      assert_match 'Expected ["/test/partial"] to include "i_was_never_rendered"', e.message
-    end
-
-    test 'specifying locals works when the partial is inside a directory with underline prefix' do
-      controller.controller_path = "test"
-      render(template: 'test/render_partial_inside_directory')
-      assert_template partial: 'test/_directory/_partial_with_locales', locals: { 'name' => 'Jane' }
-    end
-
-    test 'specifying locals works when the partial is inside a directory without underline prefix' do
-      controller.controller_path = "test"
-      render(template: 'test/render_partial_inside_directory')
-      assert_template partial: 'test/_directory/partial_with_locales', locals: { 'name' => 'Jane' }
-    end
-  end
-
-  module AHelperWithInitialize
-    def initialize(*)
-      super
-      @called_initialize = true
-    end
-  end
-
-  class AHelperWithInitializeTest < ActionView::TestCase
-    test "the helper's initialize was actually called" do
-      assert @called_initialize
-    end
-  end
-end
diff --git a/actionpack/test/template/test_test.rb b/actionpack/test/template/test_test.rb
deleted file mode 100644
index 108a674d95..0000000000
--- a/actionpack/test/template/test_test.rb
+++ /dev/null
@@ -1,80 +0,0 @@
-require 'abstract_unit'
-
-module PeopleHelper
-  def title(text)
-    content_tag(:h1, text)
-  end
-
-  def homepage_path
-    people_path
-  end
-
-  def homepage_url
-    people_url
-  end
-
-  def link_to_person(person)
-    link_to person.name, person
-  end
-end
-
-class PeopleHelperTest < ActionView::TestCase
-  def test_title
-    assert_equal "<h1>Ruby on Rails</h1>", title("Ruby on Rails")
-  end
-
-  def test_homepage_path
-    with_test_route_set do
-      assert_equal "/people", homepage_path
-    end
-  end
-
-  def test_homepage_url
-    with_test_route_set do
-      assert_equal "http://test.host/people", homepage_url
-    end
-  end
-
-  def test_link_to_person
-    with_test_route_set do
-      person = mock(:name => "David")
-      person.class.extend ActiveModel::Naming
-      expects(:mocha_mock_path).with(person).returns("/people/1")
-      assert_equal '<a href="/people/1">David</a>', link_to_person(person)
-    end
-  end
-
-  private
-    def with_test_route_set
-      with_routing do |set|
-        set.draw do
-          get 'people', :to => 'people#index', :as => :people
-        end
-        yield
-      end
-    end
-end
-
-class CrazyHelperTest < ActionView::TestCase
-  tests PeopleHelper
-
-  def test_helper_class_can_be_set_manually_not_just_inferred
-    assert_equal PeopleHelper, self.class.helper_class
-  end
-end
-
-class CrazySymbolHelperTest < ActionView::TestCase
-  tests :people
-
-  def test_set_helper_class_using_symbol
-    assert_equal PeopleHelper, self.class.helper_class
-  end
-end
-
-class CrazyStringHelperTest < ActionView::TestCase
-  tests 'people'
-
-  def test_set_helper_class_using_string
-    assert_equal PeopleHelper, self.class.helper_class
-  end
-end
diff --git a/actionpack/test/template/testing/fixture_resolver_test.rb b/actionpack/test/template/testing/fixture_resolver_test.rb
deleted file mode 100644
index 9649f349cb..0000000000
--- a/actionpack/test/template/testing/fixture_resolver_test.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-require 'abstract_unit'
-
-class FixtureResolverTest < ActiveSupport::TestCase
-  def test_should_return_empty_list_for_unknown_path
-    resolver = ActionView::FixtureResolver.new()
-    templates = resolver.find_all("path", "arbitrary", false, {:locale => [], :formats => [:html], :handlers => []})
-    assert_equal [], templates, "expected an empty list of templates"
-  end
-
-  def test_should_return_template_for_declared_path
-    resolver = ActionView::FixtureResolver.new("arbitrary/path.erb" => "this text")
-    templates = resolver.find_all("path", "arbitrary", false, {:locale => [], :formats => [:html], :handlers => [:erb]})
-    assert_equal 1, templates.size, "expected one template"
-    assert_equal "this text",      templates.first.source
-    assert_equal "arbitrary/path", templates.first.virtual_path
-    assert_equal [:html],          templates.first.formats
-  end
-end
diff --git a/actionpack/test/template/testing/null_resolver_test.rb b/actionpack/test/template/testing/null_resolver_test.rb
deleted file mode 100644
index 55ec36e753..0000000000
--- a/actionpack/test/template/testing/null_resolver_test.rb
+++ /dev/null
@@ -1,12 +0,0 @@
-require 'abstract_unit'
-
-class NullResolverTest < ActiveSupport::TestCase
-  def test_should_return_template_for_any_path
-    resolver = ActionView::NullResolver.new()
-    templates = resolver.find_all("path.erb", "arbitrary", false, {:locale => [], :formats => [:html], :handlers => []})
-    assert_equal 1, templates.size, "expected one template"
-    assert_equal "Template generated by Null Resolver", templates.first.source
-    assert_equal "arbitrary/path.erb", templates.first.virtual_path.to_s
-    assert_equal [:html],          templates.first.formats
-  end
-end
diff --git a/actionpack/test/template/text_helper_test.rb b/actionpack/test/template/text_helper_test.rb
deleted file mode 100644
index 1b2234f4e2..0000000000
--- a/actionpack/test/template/text_helper_test.rb
+++ /dev/null
@@ -1,467 +0,0 @@
-# encoding: utf-8
-require 'abstract_unit'
-
-class TextHelperTest < ActionView::TestCase
-  tests ActionView::Helpers::TextHelper
-
-  def setup
-    super
-    # This simulates the fact that instance variables are reset every time
-    # a view is rendered.  The cycle helper depends on this behavior.
-    @_cycles = nil if (defined? @_cycles)
-  end
-
-  def test_concat
-    self.output_buffer = 'foo'
-    assert_equal 'foobar', concat('bar')
-    assert_equal 'foobar', output_buffer
-  end
-
-  def test_simple_format_should_be_html_safe
-    assert simple_format("<b> test with html tags </b>").html_safe?
-  end
-
-  def test_simple_format
-    assert_equal "<p></p>", simple_format(nil)
-
-    assert_equal "<p>crazy\n<br /> cross\n<br /> platform linebreaks</p>", simple_format("crazy\r\n cross\r platform linebreaks")
-    assert_equal "<p>A paragraph</p>\n\n<p>and another one!</p>", simple_format("A paragraph\n\nand another one!")
-    assert_equal "<p>A paragraph\n<br /> With a newline</p>", simple_format("A paragraph\n With a newline")
-
-    text = "A\nB\nC\nD".freeze
-    assert_equal "<p>A\n<br />B\n<br />C\n<br />D</p>", simple_format(text)
-
-    text = "A\r\n  \nB\n\n\r\n\t\nC\nD".freeze
-    assert_equal "<p>A\n<br />  \n<br />B</p>\n\n<p>\t\n<br />C\n<br />D</p>", simple_format(text)
-
-    assert_equal %q(<p class="test">This is a classy test</p>), simple_format("This is a classy test", :class => 'test')
-    assert_equal %Q(<p class="test">para 1</p>\n\n<p class="test">para 2</p>), simple_format("para 1\n\npara 2", :class => 'test')
-  end
-
-  def test_simple_format_should_sanitize_input_when_sanitize_option_is_not_false
-    assert_equal "<p><b> test with unsafe string </b></p>", simple_format("<b> test with unsafe string </b><script>code!</script>")
-  end
-
-  def test_simple_format_should_not_sanitize_input_when_sanitize_option_is_false
-    assert_equal "<p><b> test with unsafe string </b><script>code!</script></p>", simple_format("<b> test with unsafe string </b><script>code!</script>", {}, :sanitize => false)
-  end
-
-  def test_simple_format_with_custom_wrapper
-    assert_equal "<div></div>", simple_format(nil, {}, :wrapper_tag => "div")
-  end
-
-  def test_simple_format_with_custom_wrapper_and_multi_line_breaks
-    assert_equal "<div>We want to put a wrapper...</div>\n\n<div>...right there.</div>", simple_format("We want to put a wrapper...\n\n...right there.", {}, :wrapper_tag => "div")
-  end
-
-  def test_simple_format_should_not_change_the_text_passed
-    text = "<b>Ok</b><script>code!</script>"
-    text_clone = text.dup
-    simple_format(text)
-    assert_equal text_clone, text
-  end
-
-  def test_simple_format_does_not_modify_the_html_options_hash
-    options = { :class => "foobar"}
-    passed_options = options.dup
-    simple_format("some text", passed_options)
-    assert_equal options, passed_options
-  end
-
-  def test_simple_format_does_not_modify_the_options_hash
-    options = { :wrapper_tag => :div, :sanitize => false }
-    passed_options = options.dup
-    simple_format("some text", {}, passed_options)
-    assert_equal options, passed_options
-  end
-
-  def test_truncate
-    assert_equal "Hello World!", truncate("Hello World!", :length => 12)
-    assert_equal "Hello Wor...", truncate("Hello World!!", :length => 12)
-  end
-
-  def test_truncate_should_use_default_length_of_30
-    str = "This is a string that will go longer then the default truncate length of 30"
-    assert_equal str[0...27] + "...", truncate(str)
-  end
-
-  def test_truncate_with_options_hash
-    assert_equal "This is a string that wil[...]", truncate("This is a string that will go longer then the default truncate length of 30", :omission => "[...]")
-    assert_equal "Hello W...", truncate("Hello World!", :length => 10)
-    assert_equal "Hello[...]", truncate("Hello World!", :omission => "[...]", :length => 10)
-    assert_equal "Hello[...]", truncate("Hello Big World!", :omission => "[...]", :length => 13, :separator => ' ')
-    assert_equal "Hello Big[...]", truncate("Hello Big World!", :omission => "[...]", :length => 14, :separator => ' ')
-    assert_equal "Hello Big[...]", truncate("Hello Big World!", :omission => "[...]", :length => 15, :separator => ' ')
-  end
-
-  def test_truncate_multibyte
-    assert_equal "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 ...".force_encoding(Encoding::UTF_8),
-      truncate("\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 \354\225\204\353\235\274\353\246\254\354\230\244".force_encoding(Encoding::UTF_8), :length => 10)
-  end
-
-  def test_truncate_does_not_modify_the_options_hash
-    options = { :length => 10 }
-    passed_options = options.dup
-    truncate("some text", passed_options)
-    assert_equal options, passed_options
-  end
-
-  def test_truncate_with_link_options
-    assert_equal "Here is a long test and ...<a href=\"#\">Continue</a>",
-    truncate("Here is a long test and I need a continue to read link", :length => 27) { link_to 'Continue', '#' }
-  end
-
-  def test_truncate_should_be_html_safe
-    assert truncate("Hello World!", :length => 12).html_safe?
-  end
-
-  def test_truncate_should_escape_the_input
-    assert_equal "Hello &lt;sc...", truncate("Hello <script>code!</script>World!!", :length => 12)
-  end
-
-  def test_truncate_should_not_escape_the_input_with_escape_false
-    assert_equal "Hello <sc...", truncate("Hello <script>code!</script>World!!", :length => 12, :escape => false)
-  end
-
-  def test_truncate_with_escape_false_should_be_html_safe
-    truncated = truncate("Hello <script>code!</script>World!!", :length => 12, :escape => false)
-    assert truncated.html_safe?
-  end
-
-  def test_truncate_with_block_should_be_html_safe
-    truncated = truncate("Here's a long test and I need a continue to read link", :length => 27) { link_to 'Continue', '#' }
-    assert truncated.html_safe?
-  end
-
-  def test_truncate_with_block_should_escape_the_input
-    assert_equal "&lt;script&gt;code!&lt;/script&gt;He...<a href=\"#\">Continue</a>",
-      truncate("<script>code!</script>Here's a long test and I need a continue to read link", :length => 27) { link_to 'Continue', '#' }
-  end
-
-  def test_truncate_with_block_should_not_escape_the_input_with_escape_false
-    assert_equal "<script>code!</script>He...<a href=\"#\">Continue</a>",
-      truncate("<script>code!</script>Here's a long test and I need a continue to read link", :length => 27, :escape => false) { link_to 'Continue', '#' }
-  end
-
-  def test_truncate_with_block_with_escape_false_should_be_html_safe
-    truncated = truncate("<script>code!</script>Here's a long test and I need a continue to read link", :length => 27, :escape => false) { link_to 'Continue', '#' }
-    assert truncated.html_safe?
-  end
-
-  def test_truncate_with_block_should_escape_the_block
-    assert_equal "Here is a long test and ...&lt;script&gt;alert(&#39;foo&#39;);&lt;/script&gt;",
-      truncate("Here is a long test and I need a continue to read link", :length => 27) { "<script>alert('foo');</script>" }
-  end
-
-  def test_highlight_should_be_html_safe
-    assert highlight("This is a beautiful morning", "beautiful").html_safe?
-  end
-
-  def test_highlight
-    assert_equal(
-      "This is a <mark>beautiful</mark> morning",
-      highlight("This is a beautiful morning", "beautiful")
-    )
-
-    assert_equal(
-      "This is a <mark>beautiful</mark> morning, but also a <mark>beautiful</mark> day",
-      highlight("This is a beautiful morning, but also a beautiful day", "beautiful")
-    )
-
-    assert_equal(
-      "This is a <b>beautiful</b> morning, but also a <b>beautiful</b> day",
-      highlight("This is a beautiful morning, but also a beautiful day", "beautiful", :highlighter => '<b>\1</b>')
-    )
-
-    assert_equal(
-      "This text is not changed because we supplied an empty phrase",
-      highlight("This text is not changed because we supplied an empty phrase", nil)
-    )
-
-    assert_equal '   ', highlight('   ', 'blank text is returned verbatim')
-  end
-
-  def test_highlight_should_sanitize_input
-    assert_equal(
-      "This is a <mark>beautiful</mark> morning",
-      highlight("This is a beautiful morning<script>code!</script>", "beautiful")
-    )
-  end
-
-  def test_highlight_should_not_sanitize_if_sanitize_option_if_false
-    assert_equal(
-      "This is a <mark>beautiful</mark> morning<script>code!</script>",
-      highlight("This is a beautiful morning<script>code!</script>", "beautiful", :sanitize => false)
-    )
-  end
-
-  def test_highlight_with_regexp
-    assert_equal(
-      "This is a <mark>beautiful!</mark> morning",
-      highlight("This is a beautiful! morning", "beautiful!")
-    )
-
-    assert_equal(
-      "This is a <mark>beautiful! morning</mark>",
-      highlight("This is a beautiful! morning", "beautiful! morning")
-    )
-
-    assert_equal(
-      "This is a <mark>beautiful? morning</mark>",
-      highlight("This is a beautiful? morning", "beautiful? morning")
-    )
-  end
-
-  def test_highlight_with_multiple_phrases_in_one_pass
-    assert_equal %(<em>wow</em> <em>em</em>), highlight('wow em', %w(wow em), :highlighter => '<em>\1</em>')
-  end
-
-  def test_highlight_with_html
-    assert_equal(
-      "<p>This is a <mark>beautiful</mark> morning, but also a <mark>beautiful</mark> day</p>",
-      highlight("<p>This is a beautiful morning, but also a beautiful day</p>", "beautiful")
-    )
-    assert_equal(
-      "<p>This is a <em><mark>beautiful</mark></em> morning, but also a <mark>beautiful</mark> day</p>",
-      highlight("<p>This is a <em>beautiful</em> morning, but also a beautiful day</p>", "beautiful")
-    )
-    assert_equal(
-      "<p>This is a <em class=\"error\"><mark>beautiful</mark></em> morning, but also a <mark>beautiful</mark> <span class=\"last\">day</span></p>",
-      highlight("<p>This is a <em class=\"error\">beautiful</em> morning, but also a beautiful <span class=\"last\">day</span></p>", "beautiful")
-    )
-    assert_equal(
-      "<p class=\"beautiful\">This is a <mark>beautiful</mark> morning, but also a <mark>beautiful</mark> day</p>",
-      highlight("<p class=\"beautiful\">This is a beautiful morning, but also a beautiful day</p>", "beautiful")
-    )
-    assert_equal(
-      "<p>This is a <mark>beautiful</mark> <a href=\"http://example.com/beautiful#top?what=beautiful%20morning&amp;when=now+then\">morning</a>, but also a <mark>beautiful</mark> day</p>",
-      highlight("<p>This is a beautiful <a href=\"http://example.com/beautiful\#top?what=beautiful%20morning&when=now+then\">morning</a>, but also a beautiful day</p>", "beautiful")
-    )
-    assert_equal(
-      "<div>abc <b>div</b></div>",
-      highlight("<div>abc div</div>", "div", :highlighter => '<b>\1</b>')
-    )
-  end
-
-  def test_highlight_does_not_modify_the_options_hash
-    options = { :highlighter => '<b>\1</b>', :sanitize => false }
-    passed_options = options.dup
-    highlight("<div>abc div</div>", "div", passed_options)
-    assert_equal options, passed_options
-  end
-
-  def test_excerpt
-    assert_equal("...is a beautiful morn...", excerpt("This is a beautiful morning", "beautiful", :radius => 5))
-    assert_equal("This is a...", excerpt("This is a beautiful morning", "this", :radius => 5))
-    assert_equal("...iful morning", excerpt("This is a beautiful morning", "morning", :radius => 5))
-    assert_nil excerpt("This is a beautiful morning", "day")
-  end
-
-  def test_excerpt_should_not_be_html_safe
-    assert !excerpt('This is a beautiful! morning', 'beautiful', :radius => 5).html_safe?
-  end
-
-  def test_excerpt_in_borderline_cases
-    assert_equal("", excerpt("", "", :radius => 0))
-    assert_equal("a", excerpt("a", "a", :radius => 0))
-    assert_equal("...b...", excerpt("abc", "b", :radius => 0))
-    assert_equal("abc", excerpt("abc", "b", :radius => 1))
-    assert_equal("abc...", excerpt("abcd", "b", :radius => 1))
-    assert_equal("...abc", excerpt("zabc", "b", :radius => 1))
-    assert_equal("...abc...", excerpt("zabcd", "b", :radius => 1))
-    assert_equal("zabcd", excerpt("zabcd", "b", :radius => 2))
-
-    # excerpt strips the resulting string before ap-/prepending excerpt_string.
-    # whether this behavior is meaningful when excerpt_string is not to be
-    # appended is questionable.
-    assert_equal("zabcd", excerpt("  zabcd  ", "b", :radius => 4))
-    assert_equal("...abc...", excerpt("z  abc  d", "b", :radius => 1))
-  end
-
-  def test_excerpt_with_regex
-    assert_equal('...is a beautiful! mor...', excerpt('This is a beautiful! morning', 'beautiful', :radius => 5))
-    assert_equal('...is a beautiful? mor...', excerpt('This is a beautiful? morning', 'beautiful', :radius => 5))
-  end
-
-  def test_excerpt_with_omission
-    assert_equal("[...]is a beautiful morn[...]", excerpt("This is a beautiful morning", "beautiful", :omission => "[...]",:radius => 5))
-    assert_equal(
-      "This is the ultimate supercalifragilisticexpialidoceous very looooooooooooooooooong looooooooooooong beautiful morning with amazing sunshine and awesome tempera[...]",
-      excerpt("This is the ultimate supercalifragilisticexpialidoceous very looooooooooooooooooong looooooooooooong beautiful morning with amazing sunshine and awesome temperatures. So what are you gonna do about it?", "very",
-      :omission => "[...]")
-    )
-  end
-
-  def test_excerpt_with_utf8
-    assert_equal("...\357\254\203ciency could not be...".force_encoding(Encoding::UTF_8), excerpt("That's why e\357\254\203ciency could not be helped".force_encoding(Encoding::UTF_8), 'could', :radius => 8))
-  end
-
-  def test_excerpt_does_not_modify_the_options_hash
-    options = { :omission => "[...]",:radius => 5 }
-    passed_options = options.dup
-    excerpt("This is a beautiful morning", "beautiful", passed_options)
-    assert_equal options, passed_options
-  end
-
-  def test_excerpt_with_separator
-    options = { :separator => ' ', :radius => 1 }
-    assert_equal('...a very beautiful...', excerpt('This is a very beautiful morning', 'very', options))
-    assert_equal('This is...', excerpt('This is a very beautiful morning', 'this', options))
-    assert_equal('...beautiful morning', excerpt('This is a very beautiful morning', 'morning', options))
-
-    options = { :separator => "\n", :radius => 0 }
-    assert_equal("...very long...", excerpt("my very\nvery\nvery long\nstring", 'long', options))
-
-    options = { :separator => "\n", :radius => 1 }
-    assert_equal("...very\nvery long\nstring", excerpt("my very\nvery\nvery long\nstring", 'long', options))
-  end
-
-  def test_word_wrap
-    assert_equal("my very very\nvery long\nstring", word_wrap("my very very very long string", :line_width => 15))
-  end
-
-  def test_word_wrap_with_extra_newlines
-    assert_equal("my very very\nvery long\nstring\n\nwith another\nline", word_wrap("my very very very long string\n\nwith another line", :line_width => 15))
-  end
-
-  def test_word_wrap_does_not_modify_the_options_hash
-    options = { :line_width => 15 }
-    passed_options = options.dup
-    word_wrap("some text", passed_options)
-    assert_equal options, passed_options
-  end
-
-  def test_pluralization
-    assert_equal("1 count", pluralize(1, "count"))
-    assert_equal("2 counts", pluralize(2, "count"))
-    assert_equal("1 count", pluralize('1', "count"))
-    assert_equal("2 counts", pluralize('2', "count"))
-    assert_equal("1,066 counts", pluralize('1,066', "count"))
-    assert_equal("1.25 counts", pluralize('1.25', "count"))
-    assert_equal("1.0 count", pluralize('1.0', "count"))
-    assert_equal("1.00 count", pluralize('1.00', "count"))
-    assert_equal("2 counters", pluralize(2, "count", "counters"))
-    assert_equal("0 counters", pluralize(nil, "count", "counters"))
-    assert_equal("2 people", pluralize(2, "person"))
-    assert_equal("10 buffaloes", pluralize(10, "buffalo"))
-    assert_equal("1 berry", pluralize(1, "berry"))
-    assert_equal("12 berries", pluralize(12, "berry"))
-  end
-
-  def test_cycle_class
-    value = Cycle.new("one", 2, "3")
-    assert_equal("one", value.to_s)
-    assert_equal("2", value.to_s)
-    assert_equal("3", value.to_s)
-    assert_equal("one", value.to_s)
-    value.reset
-    assert_equal("one", value.to_s)
-    assert_equal("2", value.to_s)
-    assert_equal("3", value.to_s)
-  end
-
-  def test_cycle_class_with_no_arguments
-    assert_raise(ArgumentError) { Cycle.new }
-  end
-
-  def test_cycle
-    assert_equal("one", cycle("one", 2, "3"))
-    assert_equal("2", cycle("one", 2, "3"))
-    assert_equal("3", cycle("one", 2, "3"))
-    assert_equal("one", cycle("one", 2, "3"))
-    assert_equal("2", cycle("one", 2, "3"))
-    assert_equal("3", cycle("one", 2, "3"))
-  end
-
-  def test_cycle_with_no_arguments
-    assert_raise(ArgumentError) { cycle }
-  end
-
-  def test_cycle_resets_with_new_values
-    assert_equal("even", cycle("even", "odd"))
-    assert_equal("odd", cycle("even", "odd"))
-    assert_equal("even", cycle("even", "odd"))
-    assert_equal("1", cycle(1, 2, 3))
-    assert_equal("2", cycle(1, 2, 3))
-    assert_equal("3", cycle(1, 2, 3))
-    assert_equal("1", cycle(1, 2, 3))
-  end
-
-  def test_named_cycles
-    assert_equal("1", cycle(1, 2, 3, :name => "numbers"))
-    assert_equal("red", cycle("red", "blue", :name => "colors"))
-    assert_equal("2", cycle(1, 2, 3, :name => "numbers"))
-    assert_equal("blue", cycle("red", "blue", :name => "colors"))
-    assert_equal("3", cycle(1, 2, 3, :name => "numbers"))
-    assert_equal("red", cycle("red", "blue", :name => "colors"))
-  end
-
-  def test_current_cycle_with_default_name
-    cycle("even","odd")
-    assert_equal "even", current_cycle
-    cycle("even","odd")
-    assert_equal "odd", current_cycle
-    cycle("even","odd")
-    assert_equal "even", current_cycle
-  end
-
-  def test_current_cycle_with_named_cycles
-    cycle("red", "blue", :name => "colors")
-    assert_equal "red", current_cycle("colors")
-    cycle("red", "blue", :name => "colors")
-    assert_equal "blue", current_cycle("colors")
-    cycle("red", "blue", :name => "colors")
-    assert_equal "red", current_cycle("colors")
-  end
-
-  def test_current_cycle_safe_call
-    assert_nothing_raised { current_cycle }
-    assert_nothing_raised { current_cycle("colors") }
-  end
-
-  def test_current_cycle_with_more_than_two_names
-    cycle(1,2,3)
-    assert_equal "1", current_cycle
-    cycle(1,2,3)
-    assert_equal "2", current_cycle
-    cycle(1,2,3)
-    assert_equal "3", current_cycle
-    cycle(1,2,3)
-    assert_equal "1", current_cycle
-  end
-
-  def test_default_named_cycle
-    assert_equal("1", cycle(1, 2, 3))
-    assert_equal("2", cycle(1, 2, 3, :name => "default"))
-    assert_equal("3", cycle(1, 2, 3))
-  end
-
-  def test_reset_cycle
-    assert_equal("1", cycle(1, 2, 3))
-    assert_equal("2", cycle(1, 2, 3))
-    reset_cycle
-    assert_equal("1", cycle(1, 2, 3))
-  end
-
-  def test_reset_unknown_cycle
-    reset_cycle("colors")
-  end
-
-  def test_recet_named_cycle
-    assert_equal("1", cycle(1, 2, 3, :name => "numbers"))
-    assert_equal("red", cycle("red", "blue", :name => "colors"))
-    reset_cycle("numbers")
-    assert_equal("1", cycle(1, 2, 3, :name => "numbers"))
-    assert_equal("blue", cycle("red", "blue", :name => "colors"))
-    assert_equal("2", cycle(1, 2, 3, :name => "numbers"))
-    assert_equal("red", cycle("red", "blue", :name => "colors"))
-  end
-
-  def test_cycle_no_instance_variable_clashes
-    @cycles = %w{Specialized Fuji Giant}
-    assert_equal("red", cycle("red", "blue"))
-    assert_equal("blue", cycle("red", "blue"))
-    assert_equal("red", cycle("red", "blue"))
-    assert_equal(%w{Specialized Fuji Giant}, @cycles)
-  end
-end
diff --git a/actionpack/test/template/translation_helper_test.rb b/actionpack/test/template/translation_helper_test.rb
deleted file mode 100644
index d496dbb35e..0000000000
--- a/actionpack/test/template/translation_helper_test.rb
+++ /dev/null
@@ -1,138 +0,0 @@
-require 'abstract_unit'
-
-class TranslationHelperTest < ActiveSupport::TestCase
-  include ActionView::Helpers::TagHelper
-  include ActionView::Helpers::TranslationHelper
-
-  attr_reader :request, :view
-
-  def setup
-    I18n.backend.store_translations(:en,
-      :translations => {
-        :templates => {
-          :found => { :foo => 'Foo' },
-          :array => { :foo => { :bar => 'Foo Bar' } },
-          :default => { :foo => 'Foo' }
-        },
-        :foo => 'Foo',
-        :hello => '<a>Hello World</a>',
-        :html => '<a>Hello World</a>',
-        :hello_html => '<a>Hello World</a>',
-        :interpolated_html => '<a>Hello %{word}</a>',
-        :array_html => %w(foo bar),
-        :array => %w(foo bar),
-        :count_html => {
-          :one   => '<a>One %{count}</a>',
-          :other => '<a>Other %{count}</a>'
-        }
-      }
-    )
-    @view = ::ActionView::Base.new(ActionController::Base.view_paths, {})
-  end
-
-  def test_delegates_to_i18n_setting_the_rescue_format_option_to_html
-    I18n.expects(:translate).with(:foo, :locale => 'en', :rescue_format => :html).returns("")
-    translate :foo, :locale => 'en'
-  end
-
-  def test_delegates_localize_to_i18n
-    @time = Time.utc(2008, 7, 8, 12, 18, 38)
-    I18n.expects(:localize).with(@time)
-    localize @time
-  end
-
-  def test_returns_missing_translation_message_wrapped_into_span
-    expected = '<span class="translation_missing" title="translation missing: en.translations.missing">Missing</span>'
-    assert_equal expected, translate(:"translations.missing")
-    assert_equal true, translate(:"translations.missing").html_safe?
-  end
-
-  def test_returns_missing_translation_message_using_nil_as_rescue_format
-    expected = 'translation missing: en.translations.missing'
-    assert_equal expected, translate(:"translations.missing", :rescue_format => nil)
-    assert_equal false, translate(:"translations.missing", :rescue_format => nil).html_safe?
-  end
-
-  def test_i18n_translate_defaults_to_nil_rescue_format
-    expected = 'translation missing: en.translations.missing'
-    assert_equal expected, I18n.translate(:"translations.missing")
-    assert_equal false, I18n.translate(:"translations.missing").html_safe?
-  end
-
-  def test_translation_returning_an_array
-    expected = %w(foo bar)
-    assert_equal expected, translate(:"translations.array")
-  end
-
-  def test_finds_translation_scoped_by_partial
-    assert_equal 'Foo', view.render(:file => 'translations/templates/found').strip
-  end
-
-  def test_finds_array_of_translations_scoped_by_partial
-    assert_equal 'Foo Bar', @view.render(:file => 'translations/templates/array').strip
-  end
-
-  def test_default_lookup_scoped_by_partial
-    assert_equal 'Foo', view.render(:file => 'translations/templates/default').strip
-  end
-
-  def test_missing_translation_scoped_by_partial
-    expected = '<span class="translation_missing" title="translation missing: en.translations.templates.missing.missing">Missing</span>'
-    assert_equal expected, view.render(:file => 'translations/templates/missing').strip
-  end
-
-  def test_translate_does_not_mark_plain_text_as_safe_html
-    assert_equal false, translate(:'translations.hello').html_safe?
-  end
-
-  def test_translate_marks_translations_named_html_as_safe_html
-    assert translate(:'translations.html').html_safe?
-  end
-
-  def test_translate_marks_translations_with_a_html_suffix_as_safe_html
-    assert translate(:'translations.hello_html').html_safe?
-  end
-
-  def test_translate_escapes_interpolations_in_translations_with_a_html_suffix
-    assert_equal '<a>Hello &lt;World&gt;</a>', translate(:'translations.interpolated_html', :word => '<World>')
-    assert_equal '<a>Hello &lt;World&gt;</a>', translate(:'translations.interpolated_html', :word => stub(:to_s => "<World>"))
-  end
-
-  def test_translate_with_html_count
-    assert_equal '<a>One 1</a>', translate(:'translations.count_html', :count => 1)
-    assert_equal '<a>Other 2</a>', translate(:'translations.count_html', :count => 2)
-    assert_equal '<a>Other &lt;One&gt;</a>', translate(:'translations.count_html', :count => '<One>')
-  end
-
-  def test_translation_returning_an_array_ignores_html_suffix
-    assert_equal ["foo", "bar"], translate(:'translations.array_html')
-  end
-
-  def test_translate_with_default_named_html
-    translation = translate(:'translations.missing', :default => :'translations.hello_html')
-    assert_equal '<a>Hello World</a>', translation
-    assert_equal true, translation.html_safe?
-  end
-
-  def test_translate_with_two_defaults_named_html
-    translation = translate(:'translations.missing', :default => [:'translations.missing_html', :'translations.hello_html'])
-    assert_equal '<a>Hello World</a>', translation
-    assert_equal true, translation.html_safe?
-  end
-
-  def test_translate_with_last_default_named_html
-    translation = translate(:'translations.missing', :default => [:'translations.missing', :'translations.hello_html'])
-    assert_equal '<a>Hello World</a>', translation
-    assert_equal true, translation.html_safe?
-  end
-
-  def test_translate_with_string_default
-    translation = translate(:'translations.missing', default: 'A Generic String')
-    assert_equal 'A Generic String', translation
-  end
-
-  def test_translate_with_array_of_string_defaults
-    translation = translate(:'translations.missing', default: ['A Generic String', 'Second generic string'])
-    assert_equal 'A Generic String', translation
-  end
-end
diff --git a/actionpack/test/template/url_helper_test.rb b/actionpack/test/template/url_helper_test.rb
deleted file mode 100644
index 9b4c419807..0000000000
--- a/actionpack/test/template/url_helper_test.rb
+++ /dev/null
@@ -1,829 +0,0 @@
-# encoding: utf-8
-require 'abstract_unit'
-require 'controller/fake_controllers'
-
-class UrlHelperTest < ActiveSupport::TestCase
-
-  # In a few cases, the helper proxies to 'controller'
-  # or request.
-  #
-  # In those cases, we'll set up a simple mock
-  attr_accessor :controller, :request
-
-  cattr_accessor :request_forgery
-  self.request_forgery = false
-
-  routes = ActionDispatch::Routing::RouteSet.new
-  routes.draw do
-    get "/" => "foo#bar"
-    get "/other" => "foo#other"
-    get "/article/:id" => "foo#article", :as => :article
-  end
-
-  include ActionView::Helpers::UrlHelper
-  include routes.url_helpers
-
-  include ActionView::Helpers::JavaScriptHelper
-  include ActionDispatch::Assertions::DomAssertions
-  include ActionView::Context
-  include RenderERBUtils
-
-  setup :_prepare_context
-
-  def hash_for(options = {})
-    { controller: "foo", action: "bar" }.merge!(options)
-  end
-  alias url_hash hash_for
-
-  def test_url_for_does_not_escape_urls
-    assert_equal "/?a=b&c=d", url_for(hash_for(a: :b, c: :d))
-  end
-
-  def test_url_for_with_back
-    referer = 'http://www.example.com/referer'
-    @controller = Struct.new(:request).new(Struct.new(:env).new("HTTP_REFERER" => referer))
-
-    assert_equal 'http://www.example.com/referer', url_for(:back)
-  end
-
-  def test_url_for_with_back_and_no_referer
-    @controller = Struct.new(:request).new(Struct.new(:env).new({}))
-    assert_equal 'javascript:history.back()', url_for(:back)
-  end
-
-  def test_button_to_with_straight_url
-    assert_dom_equal %{<form method="post" action="http://www.example.com" class="button_to"><div><input type="submit" value="Hello" /></div></form>}, button_to("Hello", "http://www.example.com")
-  end
-
-  def test_button_to_with_straight_url_and_request_forgery
-    self.request_forgery = true
-
-    assert_dom_equal(
-      %{<form method="post" action="http://www.example.com" class="button_to"><div><input type="submit" value="Hello" /><input name="form_token" type="hidden" value="secret" /></div></form>},
-      button_to("Hello", "http://www.example.com")
-    )
-  ensure
-    self.request_forgery = false
-  end
-
-  def test_button_to_with_form_class
-    assert_dom_equal %{<form method="post" action="http://www.example.com" class="custom-class"><div><input type="submit" value="Hello" /></div></form>}, button_to("Hello", "http://www.example.com", form_class: 'custom-class')
-  end
-
-  def test_button_to_with_form_class_escapes
-    assert_dom_equal %{<form method="post" action="http://www.example.com" class="&lt;script&gt;evil_js&lt;/script&gt;"><div><input type="submit" value="Hello" /></div></form>}, button_to("Hello", "http://www.example.com", form_class: '<script>evil_js</script>')
-  end
-
-  def test_button_to_with_query
-    assert_dom_equal %{<form method="post" action="http://www.example.com/q1=v1&amp;q2=v2" class="button_to"><div><input type="submit" value="Hello" /></div></form>}, button_to("Hello", "http://www.example.com/q1=v1&q2=v2")
-  end
-
-  def test_button_to_with_html_safe_URL
-    assert_dom_equal %{<form method="post" action="http://www.example.com/q1=v1&amp;q2=v2" class="button_to"><div><input type="submit" value="Hello" /></div></form>}, button_to("Hello", "http://www.example.com/q1=v1&amp;q2=v2".html_safe)
-  end
-
-  def test_button_to_with_query_and_no_name
-    assert_dom_equal %{<form method="post" action="http://www.example.com?q1=v1&amp;q2=v2" class="button_to"><div><input type="submit" value="http://www.example.com?q1=v1&amp;q2=v2" /></div></form>}, button_to(nil, "http://www.example.com?q1=v1&q2=v2")
-  end
-
-  def test_button_to_with_javascript_confirm
-    assert_dom_equal(
-      %{<form method="post" action="http://www.example.com" class="button_to"><div><input data-confirm="Are you sure?" type="submit" value="Hello" /></div></form>},
-      button_to("Hello", "http://www.example.com", data: { confirm: "Are you sure?" })
-    )
-  end
-
-  def test_button_to_with_deprecated_confirm
-    assert_deprecated ":confirm option is deprecated and will be removed from Rails 4.1. Use 'data: { confirm: \'Text\' }' instead" do
-      assert_dom_equal(
-        %{<form method="post" action="http://www.example.com" class="button_to"><div><input data-confirm="Are you sure?" type="submit" value="Hello" /></div></form>},
-        button_to("Hello", "http://www.example.com", confirm: "Are you sure?")
-      )
-    end
-  end
-
-  def test_button_to_with_javascript_disable_with
-    assert_dom_equal(
-      %{<form method="post" action="http://www.example.com" class="button_to"><div><input data-disable-with="Greeting..." type="submit" value="Hello" /></div></form>},
-      button_to("Hello", "http://www.example.com", data: { disable_with: "Greeting..." })
-    )
-  end
-
-  def test_button_to_with_javascript_deprecated_disable_with
-    assert_deprecated ":disable_with option is deprecated and will be removed from Rails 4.1. Use 'data: { disable_with: \'Text\' }' instead" do
-      assert_dom_equal(
-        %{<form method="post" action="http://www.example.com" class="button_to"><div><input data-disable-with="Greeting..." type="submit" value="Hello" /></div></form>},
-        button_to("Hello", "http://www.example.com", disable_with: "Greeting...")
-      )
-    end
-  end
-
-  def test_button_to_with_remote_and_form_options
-    assert_dom_equal(
-      %{<form method="post" action="http://www.example.com" class="custom-class" data-remote="true" data-type="json"><div><input type="submit" value="Hello" /></div></form>},
-      button_to("Hello", "http://www.example.com", remote: true, form: { class: "custom-class", "data-type" => "json" })
-    )
-  end
-
-  def test_button_to_with_remote_and_javascript_confirm
-    assert_dom_equal(
-      %{<form method="post" action="http://www.example.com" class="button_to" data-remote="true"><div><input data-confirm="Are you sure?" type="submit" value="Hello" /></div></form>},
-      button_to("Hello", "http://www.example.com", remote: true, data: { confirm: "Are you sure?" })
-    )
-  end
-
-  def test_button_to_with_remote_and_javascript_with_deprecated_confirm
-    assert_deprecated ":confirm option is deprecated and will be removed from Rails 4.1. Use 'data: { confirm: \'Text\' }' instead" do
-      assert_dom_equal(
-        %{<form method="post" action="http://www.example.com" class="button_to" data-remote="true"><div><input data-confirm="Are you sure?" type="submit" value="Hello" /></div></form>},
-        button_to("Hello", "http://www.example.com", remote: true, confirm: "Are you sure?")
-      )
-    end
-  end
-
-  def test_button_to_with_remote_and_javascript_disable_with
-    assert_dom_equal(
-      %{<form method="post" action="http://www.example.com" class="button_to" data-remote="true"><div><input data-disable-with="Greeting..." type="submit" value="Hello" /></div></form>},
-      button_to("Hello", "http://www.example.com", remote: true, data: { disable_with: "Greeting..." })
-    )
-  end
-
-  def test_button_to_with_remote_and_javascript_deprecated_disable_with
-    assert_deprecated ":disable_with option is deprecated and will be removed from Rails 4.1. Use 'data: { disable_with: \'Text\' }' instead" do
-      assert_dom_equal(
-        %{<form method="post" action="http://www.example.com" class="button_to" data-remote="true"><div><input data-disable-with="Greeting..." type="submit" value="Hello" /></div></form>},
-        button_to("Hello", "http://www.example.com", remote: true, disable_with: "Greeting...")
-      )
-    end
-  end
-
-  def test_button_to_with_remote_false
-    assert_dom_equal(
-      %{<form method="post" action="http://www.example.com" class="button_to"><div><input type="submit" value="Hello" /></div></form>},
-      button_to("Hello", "http://www.example.com", remote: false)
-    )
-  end
-
-  def test_button_to_enabled_disabled
-    assert_dom_equal(
-      %{<form method="post" action="http://www.example.com" class="button_to"><div><input type="submit" value="Hello" /></div></form>},
-      button_to("Hello", "http://www.example.com", disabled: false)
-    )
-    assert_dom_equal(
-      %{<form method="post" action="http://www.example.com" class="button_to"><div><input disabled="disabled" type="submit" value="Hello" /></div></form>},
-      button_to("Hello", "http://www.example.com", disabled: true)
-    )
-  end
-
-  def test_button_to_with_method_delete
-    assert_dom_equal(
-      %{<form method="post" action="http://www.example.com" class="button_to"><div><input type="hidden" name="_method" value="delete" /><input type="submit" value="Hello" /></div></form>},
-      button_to("Hello", "http://www.example.com", method: :delete)
-    )
-  end
-
-  def test_button_to_with_method_get
-    assert_dom_equal(
-      %{<form method="get" action="http://www.example.com" class="button_to"><div><input type="submit" value="Hello" /></div></form>},
-      button_to("Hello", "http://www.example.com", method: :get)
-    )
-  end
-
-  def test_button_to_with_block
-    assert_dom_equal(
-      %{<form method="post" action="http://www.example.com" class="button_to"><div><button type="submit"><span>Hello</span></button></div></form>},
-      button_to("http://www.example.com") { content_tag(:span, 'Hello') }
-    )
-  end
-
-  def test_link_tag_with_straight_url
-    assert_dom_equal %{<a href="http://www.example.com">Hello</a>}, link_to("Hello", "http://www.example.com")
-  end
-
-  def test_link_tag_without_host_option
-    assert_dom_equal(%{<a href="/">Test Link</a>}, link_to('Test Link', url_hash))
-  end
-
-  def test_link_tag_with_host_option
-    hash = hash_for(host: "www.example.com")
-    expected = %{<a href="http://www.example.com/">Test Link</a>}
-    assert_dom_equal(expected, link_to('Test Link', hash))
-  end
-
-  def test_link_tag_with_query
-    expected = %{<a href="http://www.example.com?q1=v1&amp;q2=v2">Hello</a>}
-    assert_dom_equal expected, link_to("Hello", "http://www.example.com?q1=v1&q2=v2")
-  end
-
-  def test_link_tag_with_query_and_no_name
-    expected = %{<a href="http://www.example.com?q1=v1&amp;q2=v2">http://www.example.com?q1=v1&amp;q2=v2</a>}
-    assert_dom_equal expected, link_to(nil, "http://www.example.com?q1=v1&q2=v2")
-  end
-
-  def test_link_tag_with_back
-    env = {"HTTP_REFERER" => "http://www.example.com/referer"}
-    @controller = Struct.new(:request).new(Struct.new(:env).new(env))
-    expected = %{<a href="#{env["HTTP_REFERER"]}">go back</a>}
-    assert_dom_equal expected, link_to('go back', :back)
-  end
-
-  def test_link_tag_with_back_and_no_referer
-    @controller = Struct.new(:request).new(Struct.new(:env).new({}))
-    link = link_to('go back', :back)
-    assert_dom_equal %{<a href="javascript:history.back()">go back</a>}, link
-  end
-
-  def test_link_tag_with_img
-    link = link_to("<img src='/favicon.jpg' />".html_safe, "/")
-    expected = %{<a href="/"><img src='/favicon.jpg' /></a>}
-    assert_dom_equal expected, link
-  end
-
-  def test_link_with_nil_html_options
-    link = link_to("Hello", url_hash, nil)
-    assert_dom_equal %{<a href="/">Hello</a>}, link
-  end
-
-  def test_link_tag_with_custom_onclick
-    link = link_to("Hello", "http://www.example.com", onclick: "alert('yay!')")
-    expected = %{<a href="http://www.example.com" onclick="alert(&#39;yay!&#39;)">Hello</a>}
-    assert_dom_equal expected, link
-  end
-
-  def test_link_tag_with_javascript_confirm
-    assert_dom_equal(
-      %{<a href="http://www.example.com" data-confirm="Are you sure?">Hello</a>},
-      link_to("Hello", "http://www.example.com", data: { confirm: "Are you sure?" })
-    )
-    assert_dom_equal(
-      %{<a href="http://www.example.com" data-confirm="You cant possibly be sure, can you?">Hello</a>},
-      link_to("Hello", "http://www.example.com", data: { confirm: "You cant possibly be sure, can you?" })
-    )
-    assert_dom_equal(
-      %{<a href="http://www.example.com" data-confirm="You cant possibly be sure,\n can you?">Hello</a>},
-      link_to("Hello", "http://www.example.com", data: { confirm: "You cant possibly be sure,\n can you?" })
-    )
-  end
-
-  def test_link_tag_with_deprecated_confirm
-    assert_deprecated ":confirm option is deprecated and will be removed from Rails 4.1. Use 'data: { confirm: \'Text\' }' instead" do
-      assert_dom_equal(
-        %{<a href="http://www.example.com" data-confirm="Are you sure?">Hello</a>},
-        link_to("Hello", "http://www.example.com", confirm: "Are you sure?")
-      )
-    end
-    assert_deprecated ":confirm option is deprecated and will be removed from Rails 4.1. Use 'data: { confirm: \'Text\' }' instead" do
-      assert_dom_equal(
-        %{<a href="http://www.example.com" data-confirm="You cant possibly be sure, can you?">Hello</a>},
-        link_to("Hello", "http://www.example.com", confirm: "You cant possibly be sure, can you?")
-      )
-    end
-    assert_deprecated ":confirm option is deprecated and will be removed from Rails 4.1. Use 'data: { confirm: \'Text\' }' instead" do
-      assert_dom_equal(
-        %{<a href="http://www.example.com" data-confirm="You cant possibly be sure,\n can you?">Hello</a>},
-        link_to("Hello", "http://www.example.com", confirm: "You cant possibly be sure,\n can you?")
-      )
-    end
-  end
-
-  def test_link_to_with_remote
-    assert_dom_equal(
-      %{<a href="http://www.example.com" data-remote="true">Hello</a>},
-      link_to("Hello", "http://www.example.com", remote: true)
-    )
-  end
-
-  def test_link_to_with_remote_false
-    assert_dom_equal(
-      %{<a href="http://www.example.com">Hello</a>},
-      link_to("Hello", "http://www.example.com", remote: false)
-    )
-  end
-
-  def test_link_to_with_symbolic_remote_in_non_html_options
-    assert_dom_equal(
-      %{<a href="/" data-remote="true">Hello</a>},
-      link_to("Hello", hash_for(remote: true), {})
-    )
-  end
-
-  def test_link_to_with_string_remote_in_non_html_options
-    assert_dom_equal(
-      %{<a href="/" data-remote="true">Hello</a>},
-      link_to("Hello", hash_for('remote' => true), {})
-    )
-  end
-
-  def test_link_tag_using_post_javascript
-    assert_dom_equal(
-      %{<a href="http://www.example.com" data-method="post" rel="nofollow">Hello</a>},
-      link_to("Hello", "http://www.example.com", method: :post)
-    )
-  end
-
-  def test_link_tag_using_delete_javascript
-    assert_dom_equal(
-      %{<a href="http://www.example.com" rel="nofollow" data-method="delete">Destroy</a>},
-      link_to("Destroy", "http://www.example.com", method: :delete)
-    )
-  end
-
-  def test_link_tag_using_delete_javascript_and_href
-    assert_dom_equal(
-      %{<a href="\#" rel="nofollow" data-method="delete">Destroy</a>},
-      link_to("Destroy", "http://www.example.com", method: :delete, href: '#')
-    )
-  end
-
-  def test_link_tag_using_post_javascript_and_rel
-    assert_dom_equal(
-      %{<a href="http://www.example.com" data-method="post" rel="example nofollow">Hello</a>},
-      link_to("Hello", "http://www.example.com", method: :post, rel: 'example')
-    )
-  end
-
-  def test_link_tag_using_post_javascript_and_confirm
-    assert_dom_equal(
-      %{<a href="http://www.example.com" data-method="post" rel="nofollow" data-confirm="Are you serious?">Hello</a>},
-      link_to("Hello", "http://www.example.com", method: :post, data: { confirm: "Are you serious?" })
-    )
-  end
-
-  def test_link_tag_using_post_javascript_and_with_deprecated_confirm
-    assert_deprecated ":confirm option is deprecated and will be removed from Rails 4.1. Use 'data: { confirm: \'Text\' }' instead" do
-      assert_dom_equal(
-        %{<a href="http://www.example.com" data-method="post" rel="nofollow" data-confirm="Are you serious?">Hello</a>},
-        link_to("Hello", "http://www.example.com", method: :post, confirm: "Are you serious?")
-      )
-    end
-  end
-
-  def test_link_tag_using_delete_javascript_and_href_and_confirm
-    assert_dom_equal(
-      %{<a href="\#" rel="nofollow" data-confirm="Are you serious?" data-method="delete">Destroy</a>},
-      link_to("Destroy", "http://www.example.com", method: :delete, href: '#', data: { confirm: "Are you serious?" })
-    )
-  end
-
-  def test_link_tag_using_delete_javascript_and_href_and_with_deprecated_confirm
-    assert_deprecated ":confirm option is deprecated and will be removed from Rails 4.1. Use 'data: { confirm: \'Text\' }' instead" do
-      assert_dom_equal(
-        %{<a href="\#" rel="nofollow" data-confirm="Are you serious?" data-method="delete">Destroy</a>},
-        link_to("Destroy", "http://www.example.com", method: :delete, href: '#', confirm: "Are you serious?")
-      )
-    end
-  end
-
-  def test_link_tag_with_block
-    assert_dom_equal %{<a href="/"><span>Example site</span></a>},
-      link_to('/') { content_tag(:span, 'Example site') }
-  end
-
-  def test_link_tag_with_block_and_html_options
-    assert_dom_equal %{<a class="special" href="/"><span>Example site</span></a>},
-      link_to('/', class: "special") { content_tag(:span, 'Example site') }
-  end
-
-  def test_link_tag_using_block_in_erb
-    out = render_erb %{<%= link_to('/') do %>Example site<% end %>}
-    assert_equal '<a href="/">Example site</a>', out
-  end
-
-  def test_link_tag_with_html_safe_string
-    assert_dom_equal(
-      %{<a href="/article/Gerd_M%C3%BCller">Gerd Müller</a>},
-      link_to("Gerd Müller", article_path("Gerd_Müller".html_safe))
-    )
-  end
-
-  def test_link_tag_escapes_content
-    assert_dom_equal %{<a href="/">Malicious &lt;script&gt;content&lt;/script&gt;</a>},
-      link_to("Malicious <script>content</script>", "/")
-  end
-
-  def test_link_tag_does_not_escape_html_safe_content
-    assert_dom_equal %{<a href="/">Malicious <script>content</script></a>},
-      link_to("Malicious <script>content</script>".html_safe, "/")
-  end
-
-  def test_link_to_unless
-    assert_equal "Showing", link_to_unless(true, "Showing", url_hash)
-
-    assert_dom_equal %{<a href="/">Listing</a>},
-      link_to_unless(false, "Listing", url_hash)
-
-    assert_equal "Showing", link_to_unless(true, "Showing", url_hash)
-
-    assert_equal "<strong>Showing</strong>",
-      link_to_unless(true, "Showing", url_hash) { |name|
-        "<strong>#{name}</strong>".html_safe
-      }
-
-    assert_equal "test",
-      link_to_unless(true, "Showing", url_hash) {
-        "test"
-      }
-  end
-
-  def test_link_to_if
-    assert_equal "Showing", link_to_if(false, "Showing", url_hash)
-    assert_dom_equal %{<a href="/">Listing</a>}, link_to_if(true, "Listing", url_hash)
-    assert_equal "Showing", link_to_if(false, "Showing", url_hash)
-  end
-
-  def request_for_url(url, opts = {})
-    env = Rack::MockRequest.env_for("http://www.example.com#{url}", opts)
-    ActionDispatch::Request.new(env)
-  end
-
-  def test_current_page_with_http_head_method
-    @request = request_for_url("/", :method => :head)
-    assert current_page?(url_hash)
-    assert current_page?("http://www.example.com/")
-  end
-
-  def test_current_page_with_simple_url
-    @request = request_for_url("/")
-    assert current_page?(url_hash)
-    assert current_page?("http://www.example.com/")
-  end
-
-  def test_current_page_ignoring_params
-    @request = request_for_url("/?order=desc&page=1")
-
-    assert current_page?(url_hash)
-    assert current_page?("http://www.example.com/")
-  end
-
-  def test_current_page_with_params_that_match
-    @request = request_for_url("/?order=desc&page=1")
-
-    assert current_page?(hash_for(order: "desc", page: "1"))
-    assert current_page?("http://www.example.com/?order=desc&page=1")
-  end
-
-  def test_current_page_with_not_get_verb
-    @request = request_for_url("/events", method: :post)
-
-    assert !current_page?('/events')
-  end
-
-  def test_link_unless_current
-    @request = request_for_url("/")
-
-    assert_equal "Showing",
-      link_to_unless_current("Showing", url_hash)
-    assert_equal "Showing",
-      link_to_unless_current("Showing", "http://www.example.com/")
-
-    @request = request_for_url("/?order=desc")
-
-    assert_equal "Showing",
-      link_to_unless_current("Showing", url_hash)
-    assert_equal "Showing",
-      link_to_unless_current("Showing", "http://www.example.com/")
-
-    @request = request_for_url("/?order=desc&page=1")
-
-    assert_equal "Showing",
-      link_to_unless_current("Showing", hash_for(order: 'desc', page: '1'))
-    assert_equal "Showing",
-      link_to_unless_current("Showing", "http://www.example.com/?order=desc&page=1")
-
-    @request = request_for_url("/?order=desc")
-
-    assert_equal %{<a href="/?order=asc">Showing</a>},
-      link_to_unless_current("Showing", hash_for(order: :asc))
-    assert_equal %{<a href="http://www.example.com/?order=asc">Showing</a>},
-      link_to_unless_current("Showing", "http://www.example.com/?order=asc")
-
-    @request = request_for_url("/?order=desc")
-    assert_equal %{<a href="/?order=desc&amp;page=2\">Showing</a>},
-      link_to_unless_current("Showing", hash_for(order: "desc", page: 2))
-    assert_equal %{<a href="http://www.example.com/?order=desc&amp;page=2">Showing</a>},
-      link_to_unless_current("Showing", "http://www.example.com/?order=desc&page=2")
-
-    @request = request_for_url("/show")
-
-    assert_equal %{<a href="/">Listing</a>},
-      link_to_unless_current("Listing", url_hash)
-    assert_equal %{<a href="http://www.example.com/">Listing</a>},
-      link_to_unless_current("Listing", "http://www.example.com/")
-  end
-
-  def test_mail_to
-    assert_dom_equal %{<a href="mailto:david@loudthinking.com">david@loudthinking.com</a>}, mail_to("david@loudthinking.com")
-    assert_dom_equal %{<a href="mailto:david@loudthinking.com">David Heinemeier Hansson</a>}, mail_to("david@loudthinking.com", "David Heinemeier Hansson")
-    assert_dom_equal(
-      %{<a class="admin" href="mailto:david@loudthinking.com">David Heinemeier Hansson</a>},
-      mail_to("david@loudthinking.com", "David Heinemeier Hansson", "class" => "admin")
-    )
-    assert_equal mail_to("david@loudthinking.com", "David Heinemeier Hansson", "class" => "admin"),
-                 mail_to("david@loudthinking.com", "David Heinemeier Hansson", class: "admin")
-  end
-
-  def test_mail_with_options
-    assert_dom_equal(
-      %{<a href="mailto:me@example.com?cc=ccaddress%40example.com&amp;bcc=bccaddress%40example.com&amp;body=This%20is%20the%20body%20of%20the%20message.&amp;subject=This%20is%20an%20example%20email">My email</a>},
-      mail_to("me@example.com", "My email", cc: "ccaddress@example.com", bcc: "bccaddress@example.com", subject: "This is an example email", body: "This is the body of the message.")
-    )
-  end
-
-  def test_mail_to_with_img
-    assert_dom_equal %{<a href="mailto:feedback@example.com"><img src="/feedback.png" /></a>},
-      mail_to('feedback@example.com', '<img src="/feedback.png" />'.html_safe)
-  end
-
-  def test_mail_to_returns_html_safe_string
-    assert mail_to("david@loudthinking.com").html_safe?
-  end
-
-  def test_mail_to_with_block
-    assert_dom_equal %{<a href="mailto:me@example.com"><span>Email me</span></a>},
-      mail_to('me@example.com') { content_tag(:span, 'Email me') }
-  end
-
-  def test_mail_to_with_block_and_options
-    assert_dom_equal %{<a class="special" href="mailto:me@example.com?cc=ccaddress%40example.com"><span>Email me</span></a>},
-      mail_to('me@example.com', cc: "ccaddress@example.com", class: "special") { content_tag(:span, 'Email me') }
-  end
-
-  def test_mail_to_does_not_modify_html_options_hash
-    options = { class: 'special' }
-    mail_to 'me@example.com', 'ME!', options
-    assert_equal({ class: 'special' }, options)
-  end
-
-  def protect_against_forgery?
-    self.request_forgery
-  end
-
-  def form_authenticity_token
-    "secret"
-  end
-
-  def request_forgery_protection_token
-    "form_token"
-  end
-
-  private
-    def sort_query_string_params(uri)
-      path, qs = uri.split('?')
-      qs = qs.split('&amp;').sort.join('&amp;') if qs
-      qs ? "#{path}?#{qs}" : path
-    end
-end
-
-class UrlHelperControllerTest < ActionController::TestCase
-  class UrlHelperController < ActionController::Base
-    test_routes do
-      get 'url_helper_controller_test/url_helper/show/:id',
-        to: 'url_helper_controller_test/url_helper#show',
-        as: :show
-
-      get 'url_helper_controller_test/url_helper/profile/:name',
-        to: 'url_helper_controller_test/url_helper#show',
-        as: :profile
-
-      get 'url_helper_controller_test/url_helper/show_named_route',
-        to: 'url_helper_controller_test/url_helper#show_named_route',
-        as: :show_named_route
-
-      get "/:controller(/:action(/:id))"
-
-      get 'url_helper_controller_test/url_helper/normalize_recall_params',
-        to: UrlHelperController.action(:normalize_recall),
-        as: :normalize_recall_params
-
-      get '/url_helper_controller_test/url_helper/override_url_helper/default',
-        to: 'url_helper_controller_test/url_helper#override_url_helper',
-        as: :override_url_helper
-    end
-
-    def show
-      if params[:name]
-        render inline: 'ok'
-      else
-        redirect_to profile_path(params[:id])
-      end
-    end
-
-    def show_url_for
-      render inline: "<%= url_for controller: 'url_helper_controller_test/url_helper', action: 'show_url_for' %>"
-    end
-
-    def show_overridden_url_for
-      render inline: "<%= url_for params.merge(controller: 'url_helper_controller_test/url_helper', action: 'show_url_for') %>"
-    end
-
-    def show_named_route
-      render inline: "<%= show_named_route_#{params[:kind]} %>"
-    end
-
-    def nil_url_for
-      render inline: '<%= url_for(nil) %>'
-    end
-
-    def normalize_recall_params
-      render inline: '<%= normalize_recall_params_path %>'
-    end
-
-    def recall_params_not_changed
-      render inline: '<%= url_for(action: :show_url_for) %>'
-    end
-
-    def override_url_helper
-      render inline: '<%= override_url_helper_path %>'
-    end
-
-    def override_url_helper_path
-      '/url_helper_controller_test/url_helper/override_url_helper/override'
-    end
-    helper_method :override_url_helper_path
-  end
-
-  tests UrlHelperController
-
-  def test_url_for_shows_only_path
-    get :show_url_for
-    assert_equal '/url_helper_controller_test/url_helper/show_url_for', @response.body
-  end
-
-  def test_overridden_url_for_shows_only_path
-    get :show_overridden_url_for
-    assert_equal '/url_helper_controller_test/url_helper/show_url_for', @response.body
-  end
-
-  def test_named_route_url_shows_host_and_path
-    get :show_named_route, kind: 'url'
-    assert_equal 'http://test.host/url_helper_controller_test/url_helper/show_named_route',
-      @response.body
-  end
-
-  def test_named_route_path_shows_only_path
-    get :show_named_route, kind: 'path'
-    assert_equal '/url_helper_controller_test/url_helper/show_named_route', @response.body
-  end
-
-  def test_url_for_nil_returns_current_path
-    get :nil_url_for
-    assert_equal '/url_helper_controller_test/url_helper/nil_url_for', @response.body
-  end
-
-  def test_named_route_should_show_host_and_path_using_controller_default_url_options
-    class << @controller
-      def default_url_options
-        { host: 'testtwo.host' }
-      end
-    end
-
-    get :show_named_route, kind: 'url'
-    assert_equal 'http://testtwo.host/url_helper_controller_test/url_helper/show_named_route', @response.body
-  end
-
-  def test_recall_params_should_be_normalized
-    get :normalize_recall_params
-    assert_equal '/url_helper_controller_test/url_helper/normalize_recall_params', @response.body
-  end
-
-  def test_recall_params_should_not_be_changed
-    get :recall_params_not_changed
-    assert_equal '/url_helper_controller_test/url_helper/show_url_for', @response.body
-  end
-
-  def test_recall_params_should_normalize_id
-    get :show, id: '123'
-    assert_equal 302, @response.status
-    assert_equal 'http://test.host/url_helper_controller_test/url_helper/profile/123', @response.location
-
-    get :show, name: '123'
-    assert_equal 'ok', @response.body
-  end
-
-  def test_url_helper_can_be_overridden
-    get :override_url_helper
-    assert_equal '/url_helper_controller_test/url_helper/override_url_helper/override', @response.body
-  end
-end
-
-class TasksController < ActionController::Base
-  test_routes do
-    resources :tasks
-  end
-
-  def index
-    render_default
-  end
-
-  def show
-    render_default
-  end
-
-  protected
-    def render_default
-      render inline: "<%= link_to_unless_current('tasks', tasks_path) %>\n" +
-        "<%= link_to_unless_current('tasks', tasks_url) %>"
-    end
-end
-
-class LinkToUnlessCurrentWithControllerTest < ActionController::TestCase
-  tests TasksController
-
-  def test_link_to_unless_current_to_current
-    get :index
-    assert_equal "tasks\ntasks", @response.body
-  end
-
-  def test_link_to_unless_current_shows_link
-    get :show, id: 1
-    assert_equal %{<a href="/tasks">tasks</a>\n} +
-      %{<a href="#{@request.protocol}#{@request.host_with_port}/tasks">tasks</a>},
-      @response.body
-  end
-end
-
-class Session
-  extend ActiveModel::Naming
-  include ActiveModel::Conversion
-  attr_accessor :id, :workshop_id
-
-  def initialize(id)
-    @id = id
-  end
-
-  def persisted?
-    id.present?
-  end
-
-  def to_s
-    id.to_s
-  end
-end
-
-class WorkshopsController < ActionController::Base
-  test_routes do
-    resources :workshops do
-      resources :sessions
-    end
-  end
-
-  def index
-    @workshop = Workshop.new(nil)
-    render inline: "<%= url_for(@workshop) %>\n<%= link_to('Workshop', @workshop) %>"
-  end
-
-  def show
-    @workshop = Workshop.new(params[:id])
-    render inline: "<%= url_for(@workshop) %>\n<%= link_to('Workshop', @workshop) %>"
-  end
-end
-
-class SessionsController < ActionController::Base
-  test_routes do
-    resources :workshops do
-      resources :sessions
-    end
-  end
-
-  def index
-    @workshop = Workshop.new(params[:workshop_id])
-    @session = Session.new(nil)
-    render inline: "<%= url_for([@workshop, @session]) %>\n<%= link_to('Session', [@workshop, @session]) %>"
-  end
-
-  def show
-    @workshop = Workshop.new(params[:workshop_id])
-    @session = Session.new(params[:id])
-    render inline: "<%= url_for([@workshop, @session]) %>\n<%= link_to('Session', [@workshop, @session]) %>"
-  end
-end
-
-class PolymorphicControllerTest < ActionController::TestCase
-  def test_new_resource
-    @controller = WorkshopsController.new
-
-    get :index
-    assert_equal %{/workshops\n<a href="/workshops">Workshop</a>}, @response.body
-  end
-
-  def test_existing_resource
-    @controller = WorkshopsController.new
-
-    get :show, id: 1
-    assert_equal %{/workshops/1\n<a href="/workshops/1">Workshop</a>}, @response.body
-  end
-
-  def test_new_nested_resource
-    @controller = SessionsController.new
-
-    get :index, workshop_id: 1
-    assert_equal %{/workshops/1/sessions\n<a href="/workshops/1/sessions">Session</a>}, @response.body
-  end
-
-  def test_existing_nested_resource
-    @controller = SessionsController.new
-
-    get :show, workshop_id: 1, id: 1
-    assert_equal %{/workshops/1/sessions/1\n<a href="/workshops/1/sessions/1">Session</a>}, @response.body
-  end
-end
diff --git a/actionpack/test/ts_isolated.rb b/actionpack/test/ts_isolated.rb
deleted file mode 100644
index 55620abe84..0000000000
--- a/actionpack/test/ts_isolated.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-require 'active_support/testing/autorun'
-require 'rbconfig'
-require 'abstract_unit'
-
-class TestIsolated < ActiveSupport::TestCase
-  ruby = File.join(*RbConfig::CONFIG.values_at('bindir', 'RUBY_INSTALL_NAME'))
-
-  Dir["#{File.dirname(__FILE__)}/{abstract,controller,dispatch,template}/**/*_test.rb"].each do |file|
-    define_method("test #{file}") do
-      command = "#{ruby} -Ilib:test #{file}"
-      result = silence_stderr { `#{command}` }
-      assert $?.to_i.zero?, "#{command}\n#{result}"
-    end
-  end
-end