Merge branch 'master' of github.com:lifo/docrails

10 files changed, 819 insertions, 2401 deletions

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/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 3b5d7ef446..e58a1aadb8 100644
--- a/actionpack/test/controller/filters_test.rb
+++ b/actionpack/test/controller/filters_test.rb
@@ -17,7 +17,7 @@ class ActionController::Base
   def assigns(key = nil)
     assigns = {}
     instance_variables.each do |ivar|
-      next if ActionController::Base.protected_instance_variables.include?(ivar)
+      next if ActionController::Base.default_protected_instance_vars.include?(ivar)
       assigns[ivar[1..-1]] = instance_variable_get(ivar)
     end
 
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 e727b27db0..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
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..774dabe105
--- /dev/null
+++ b/actionpack/test/controller/mime/respond_to_test.rb
@@ -0,0 +1,493 @@
+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
+
+  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
+end
diff --git a/actionpack/test/controller/mime_responds_test.rb b/actionpack/test/controller/mime/respond_with_test.rb
index a9c62899b5..76af9e3414 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
@@ -631,6 +107,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))
@@ -847,6 +337,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 +622,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 +662,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/render_test.rb b/actionpack/test/controller/render_test.rb
index fd835795c0..f41287381a 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,788 +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_bad_accepts_header
-    @request.env["HTTP_ACCEPT"] = "; a=dsf"
-    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"]
@@ -1598,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
 
@@ -1683,7 +389,6 @@ class EtagRenderTest < ActionController::TestCase
 
   def setup
     super
-    @request.host = "www.nextangle.com"
   end
 
   def test_multiple_etags
@@ -1711,7 +416,6 @@ class EtagRenderTest < ActionController::TestCase
   end
 end
 
-
 class MetalRenderTest < ActionController::TestCase
   tests MetalTestController
 
@@ -1720,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
\ No newline at end of file
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