Bring abstract_controller up to date with rails/master

Resolved all the conflicts since 2.3.0 -> HEAD. Following is a list
of commits that could not be applied cleanly or are obviated with the
abstract_controller refactor. They all need to be revisited to ensure
that fixes made in 2.3 do not reappear in 3.0:

2259ecf368e6a6715966f69216e3ee86bf1a82a7
AR not available
  * This will be reimplemented with ActionORM or equivalent

06182ea02e92afad579998aa80144588e8865ac3
implicitly rendering a js response should not use the default layout
[#1844 state:resolved]
  * This will be handled generically

893e9eb99504705419ad6edac14d00e71cef5f12
Improve view rendering performance in development mode and reinstate
template recompiling in production [#1909 state:resolved]
  * We will need to reimplement rails-dev-boost on top of the refactor;
    the changes here are very implementation specific and cannot be
    cleanly applied. The following commits are implicated:

      199e750d46c04970b5e7684998d09405648ecbd4
      3942cb406e1d5db0ac00e03153809cc8dc4cc4db
      f8ea9f85d4f1e3e6f3b5d895bef6b013aa4b0690
      e3b166aab37ddc2fbab030b146eb61713b91bf55
      ae9f258e03c9fd5088da12c1c6cd216cc89a01f7
      44423126c6f6133a1d9cf1d0832b527e8711d40f

0cb020b4d6d838025859bd60fb8151c8e21b8e84
workaround for picking layouts based on wrong view_paths
[#1974 state:resolved]
  * The specifics of this commit no longer apply. Since it is a two-line
    commit, we will reimplement this change.

8c5cc66a831aadb159f3daaffa4208064c30af0e
make action_controller/layouts pick templates from the current instance's
view_paths instead of the class view_paths [#1974 state:resolved]
  * This does not apply at all. It should be trivial to apply the feature
    to the reimplemented ActionController::Base.

87e8b162463f13bd50d27398f020769460a770e3
fix HTML fallback for explicit templates [#2052 state:resolved]
  * There were a number of patches related to this that simply compounded
    each other. Basically none of them apply cleanly, and the underlying
    issue needs to be revisited. After discussing the underlying problem
    with Koz, we will defer these fixes for further discussion.

25 files changed, 2257 insertions, 1677 deletions

diff --git a/actionpack/test/controller/assert_select_test.rb b/actionpack/test/controller/assert_select_test.rb
index 3db1d4addf..ad17d1288b 100644
--- a/actionpack/test/controller/assert_select_test.rb
+++ b/actionpack/test/controller/assert_select_test.rb
@@ -78,7 +78,7 @@ class AssertSelectTest < ActionController::TestCase
   end
 
   def assert_failure(message, &block)
-    e = assert_raises(Assertion, &block)
+    e = assert_raise(Assertion, &block)
     assert_match(message, e.message) if Regexp === message
     assert_equal(message, e.message) if String === message
   end
@@ -97,24 +97,24 @@ class AssertSelectTest < ActionController::TestCase
   def test_equality_true_false
     render_html %Q{<div id="1"></div><div id="2"></div>}
     assert_nothing_raised    { assert_select "div" }
-    assert_raises(Assertion) { assert_select "p" }
+    assert_raise(Assertion) { assert_select "p" }
     assert_nothing_raised    { assert_select "div", true }
-    assert_raises(Assertion) { assert_select "p", true }
-    assert_raises(Assertion) { assert_select "div", false }
+    assert_raise(Assertion) { assert_select "p", true }
+    assert_raise(Assertion) { assert_select "div", false }
     assert_nothing_raised    { assert_select "p", false }
   end
 
   def test_equality_string_and_regexp
     render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
     assert_nothing_raised    { assert_select "div", "foo" }
-    assert_raises(Assertion) { assert_select "div", "bar" }
+    assert_raise(Assertion) { assert_select "div", "bar" }
     assert_nothing_raised    { assert_select "div", :text=>"foo" }
-    assert_raises(Assertion) { assert_select "div", :text=>"bar" }
+    assert_raise(Assertion) { assert_select "div", :text=>"bar" }
     assert_nothing_raised    { assert_select "div", /(foo|bar)/ }
-    assert_raises(Assertion) { assert_select "div", /foobar/ }
+    assert_raise(Assertion) { assert_select "div", /foobar/ }
     assert_nothing_raised    { assert_select "div", :text=>/(foo|bar)/ }
-    assert_raises(Assertion) { assert_select "div", :text=>/foobar/ }
-    assert_raises(Assertion) { assert_select "p", :text=>/foobar/ }
+    assert_raise(Assertion) { assert_select "div", :text=>/foobar/ }
+    assert_raise(Assertion) { assert_select "p", :text=>/foobar/ }
   end
 
   def test_equality_of_html
@@ -122,17 +122,17 @@ class AssertSelectTest < ActionController::TestCase
     text = "\"This is not a big problem,\" he said."
     html = "<em>\"This is <strong>not</strong> a big problem,\"</em> he said."
     assert_nothing_raised    { assert_select "p", text }
-    assert_raises(Assertion) { assert_select "p", html }
+    assert_raise(Assertion) { assert_select "p", html }
     assert_nothing_raised    { assert_select "p", :html=>html }
-    assert_raises(Assertion) { assert_select "p", :html=>text }
+    assert_raise(Assertion) { assert_select "p", :html=>text }
     # No stripping for pre.
     render_html %Q{<pre>\n<em>"This is <strong>not</strong> a big problem,"</em> he said.\n</pre>}
     text = "\n\"This is not a big problem,\" he said.\n"
     html = "\n<em>\"This is <strong>not</strong> a big problem,\"</em> he said.\n"
     assert_nothing_raised    { assert_select "pre", text }
-    assert_raises(Assertion) { assert_select "pre", html }
+    assert_raise(Assertion) { assert_select "pre", html }
     assert_nothing_raised    { assert_select "pre", :html=>html }
-    assert_raises(Assertion) { assert_select "pre", :html=>text }
+    assert_raise(Assertion) { assert_select "pre", :html=>text }
   end
 
   def test_counts
@@ -212,12 +212,12 @@ class AssertSelectTest < ActionController::TestCase
       assert_nothing_raised    { assert_select "div", "bar" }
       assert_nothing_raised    { assert_select "div", /\w*/ }
       assert_nothing_raised    { assert_select "div", /\w*/, :count=>2 }
-      assert_raises(Assertion) { assert_select "div", :text=>"foo", :count=>2 }
+      assert_raise(Assertion) { assert_select "div", :text=>"foo", :count=>2 }
       assert_nothing_raised    { assert_select "div", :html=>"<span>bar</span>" }
       assert_nothing_raised    { assert_select "div", :html=>"<span>bar</span>" }
       assert_nothing_raised    { assert_select "div", :html=>/\w*/ }
       assert_nothing_raised    { assert_select "div", :html=>/\w*/, :count=>2 }
-      assert_raises(Assertion) { assert_select "div", :html=>"<span>foo</span>", :count=>2 }
+      assert_raise(Assertion) { assert_select "div", :html=>"<span>foo</span>", :count=>2 }
     end
   end
 
@@ -255,7 +255,12 @@ class AssertSelectTest < ActionController::TestCase
       page.insert_html :top, "test1", "<div id=\"1\">foo</div>"
       page.insert_html :bottom, "test2", "<div id=\"2\">foo</div>"
     end
-    assert_raises(Assertion) {assert_select_rjs :insert, :top, "test2"}
+    assert_raise(Assertion) {assert_select_rjs :insert, :top, "test2"}
+  end
+
+  def test_elect_with_xml_namespace_attributes
+    render_html %Q{<link xlink:href="http://nowhere.com"></link>}
+    assert_nothing_raised { assert_select "link[xlink:href=http://nowhere.com]" }
   end
 
   #
@@ -333,7 +338,7 @@ class AssertSelectTest < ActionController::TestCase
   # Test that we fail if there is nothing to pick.
   def test_assert_select_rjs_fails_if_nothing_to_pick
     render_rjs { }
-    assert_raises(Assertion) { assert_select_rjs }
+    assert_raise(Assertion) { assert_select_rjs }
   end
 
   def test_assert_select_rjs_with_unicode
@@ -348,10 +353,10 @@ class AssertSelectTest < ActionController::TestCase
       if str.respond_to?(:force_encoding)
         str.force_encoding(Encoding::UTF_8)
         assert_select str, /\343\203\201..\343\203\210/u
-        assert_raises(Assertion) { assert_select str, /\343\203\201.\343\203\210/u }
+        assert_raise(Assertion) { assert_select str, /\343\203\201.\343\203\210/u }
       else
         assert_select str, Regexp.new("\343\203\201..\343\203\210",0,'U')
-        assert_raises(Assertion) { assert_select str, Regexp.new("\343\203\201.\343\203\210",0,'U') }
+        assert_raise(Assertion) { assert_select str, Regexp.new("\343\203\201.\343\203\210",0,'U') }
       end
     end
   end
@@ -375,7 +380,7 @@ class AssertSelectTest < ActionController::TestCase
       assert_select "div", 1
       assert_select "#3"
     end
-    assert_raises(Assertion) { assert_select_rjs "test4" }
+    assert_raise(Assertion) { assert_select_rjs "test4" }
   end
 
   def test_assert_select_rjs_for_replace
@@ -393,7 +398,7 @@ class AssertSelectTest < ActionController::TestCase
       assert_select "div", 1
       assert_select "#1"
     end
-    assert_raises(Assertion) { assert_select_rjs :replace, "test2" }
+    assert_raise(Assertion) { assert_select_rjs :replace, "test2" }
     # Replace HTML.
     assert_select_rjs :replace_html do
       assert_select "div", 1
@@ -403,7 +408,7 @@ class AssertSelectTest < ActionController::TestCase
       assert_select "div", 1
       assert_select "#2"
     end
-    assert_raises(Assertion) { assert_select_rjs :replace_html, "test1" }
+    assert_raise(Assertion) { assert_select_rjs :replace_html, "test1" }
   end
 
   def test_assert_select_rjs_for_chained_replace
@@ -421,7 +426,7 @@ class AssertSelectTest < ActionController::TestCase
       assert_select "div", 1
       assert_select "#1"
     end
-    assert_raises(Assertion) { assert_select_rjs :chained_replace, "test2" }
+    assert_raise(Assertion) { assert_select_rjs :chained_replace, "test2" }
     # Replace HTML.
     assert_select_rjs :chained_replace_html do
       assert_select "div", 1
@@ -431,7 +436,7 @@ class AssertSelectTest < ActionController::TestCase
       assert_select "div", 1
       assert_select "#2"
     end
-    assert_raises(Assertion) { assert_select_rjs :replace_html, "test1" }
+    assert_raise(Assertion) { assert_select_rjs :replace_html, "test1" }
   end
 
   # Simple remove
@@ -577,7 +582,7 @@ class AssertSelectTest < ActionController::TestCase
       assert_select "div", 1
       assert_select "#3"
     end
-    assert_raises(Assertion) { assert_select_rjs :insert_html, "test1" }
+    assert_raise(Assertion) { assert_select_rjs :insert_html, "test1" }
   end
 
   # Positioned insert.
@@ -610,8 +615,8 @@ class AssertSelectTest < ActionController::TestCase
   end
 
   def test_assert_select_rjs_raise_errors
-    assert_raises(ArgumentError) { assert_select_rjs(:destroy) }
-    assert_raises(ArgumentError) { assert_select_rjs(:insert, :left) }
+    assert_raise(ArgumentError) { assert_select_rjs(:destroy) }
+    assert_raise(ArgumentError) { assert_select_rjs(:insert, :left) }
   end
 
   # Simple selection from a single result.
@@ -703,7 +708,7 @@ EOF
   #
 
   def test_assert_select_email
-    assert_raises(Assertion) { assert_select_email {} }
+    assert_raise(Assertion) { assert_select_email {} }
     AssertSelectMailer.deliver_test "<div><p>foo</p><p>bar</p></div>"
     assert_select_email do
       assert_select "div:root" do
diff --git a/actionpack/test/controller/caching_test.rb b/actionpack/test/controller/caching_test.rb
index d743f50dff..b61a58dd09 100644
--- a/actionpack/test/controller/caching_test.rb
+++ b/actionpack/test/controller/caching_test.rb
@@ -109,13 +109,11 @@ class PageCachingTest < ActionController::TestCase
     assert File.exist?("#{FILE_STORE_PATH}/page_caching_test/trailing_slash.html")
   end
 
-  uses_mocha("should_cache_ok_at_custom_path") do
-    def test_should_cache_ok_at_custom_path
-      @request.stubs(:path).returns("/index.html")
-      get :ok
-      assert_response :ok
-      assert File.exist?("#{FILE_STORE_PATH}/index.html")
-    end
+  def test_should_cache_ok_at_custom_path
+    @request.stubs(:path).returns("/index.html")
+    get :ok
+    assert_response :ok
+    assert File.exist?("#{FILE_STORE_PATH}/index.html")
   end
 
   [:ok, :no_content, :found, :not_found].each do |status|
@@ -293,13 +291,11 @@ class ActionCacheTest < ActionController::TestCase
     ActionController::Base.use_accept_header = old_use_accept_header
   end
 
-  uses_mocha 'test action cache' do
-    def test_action_cache_with_store_options
-      MockTime.expects(:now).returns(12345).once
-      @controller.expects(:read_fragment).with('hostname.com/action_caching_test', :expires_in => 1.hour).once
-      @controller.expects(:write_fragment).with('hostname.com/action_caching_test', '12345.0', :expires_in => 1.hour).once
-      get :index
-    end
+  def test_action_cache_with_store_options
+    MockTime.expects(:now).returns(12345).once
+    @controller.expects(:read_fragment).with('hostname.com/action_caching_test', :expires_in => 1.hour).once
+    @controller.expects(:write_fragment).with('hostname.com/action_caching_test', '12345.0', :expires_in => 1.hour).once
+    get :index
   end
 
   def test_action_cache_with_custom_cache_path
@@ -434,6 +430,20 @@ class ActionCacheTest < ActionController::TestCase
     assert_equal 'application/xml', @response.content_type
   end
 
+  def test_correct_content_type_is_returned_for_cache_hit_on_action_with_string_key
+    # run it twice to cache it the first time
+    get :show, :format => 'xml'
+    get :show, :format => 'xml'
+    assert_equal 'application/xml', @response.content_type
+  end
+
+  def test_correct_content_type_is_returned_for_cache_hit_on_action_with_string_key_from_proc
+    # run it twice to cache it the first time
+    get :edit, :id => 1, :format => 'xml'
+    get :edit, :id => 1, :format => 'xml'
+    assert_equal 'application/xml', @response.content_type
+  end
+
   def test_empty_path_is_normalized
     @mock_controller.mock_url_for = 'http://example.org/'
     @mock_controller.mock_path    = '/'
diff --git a/actionpack/test/controller/cookie_test.rb b/actionpack/test/controller/cookie_test.rb
index 5a00de50ac..c861982698 100644
--- a/actionpack/test/controller/cookie_test.rb
+++ b/actionpack/test/controller/cookie_test.rb
@@ -6,6 +6,10 @@ class CookieTest < ActionController::TestCase
       cookies["user_name"] = "david"
     end
 
+    def set_with_with_escapable_characters
+      cookies["that & guy"] = "foo & bar => baz"
+    end
+
     def authenticate_for_fourteen_days
       cookies["user_name"] = { "value" => "david", "expires" => Time.utc(2005, 10, 10,5) }
     end
@@ -33,7 +37,7 @@ class CookieTest < ActionController::TestCase
     end
 
     def authenticate_with_http_only
-      cookies["user_name"] = { :value => "david", :http_only => true }
+      cookies["user_name"] = { :value => "david", :httponly => true }
     end
 
     def rescue_action(e)
@@ -54,6 +58,12 @@ class CookieTest < ActionController::TestCase
     assert_equal({"user_name" => "david"}, @response.cookies)
   end
 
+  def test_setting_with_escapable_characters
+    get :set_with_with_escapable_characters
+    assert_equal ["that+%26+guy=foo+%26+bar+%3D%3E+baz; path=/"], @response.headers["Set-Cookie"]
+    assert_equal({"that & guy" => "foo & bar => baz"}, @response.cookies)
+  end
+
   def test_setting_cookie_for_fourteen_days
     get :authenticate_for_fourteen_days
     assert_equal ["user_name=david; path=/; expires=Mon, 10-Oct-2005 05:00:00 GMT"], @response.headers["Set-Cookie"]
diff --git a/actionpack/test/controller/dispatcher_test.rb b/actionpack/test/controller/dispatcher_test.rb
index 6b409c9ae2..031a10975d 100644
--- a/actionpack/test/controller/dispatcher_test.rb
+++ b/actionpack/test/controller/dispatcher_test.rb
@@ -1,21 +1,22 @@
 require 'abstract_unit'
 
-uses_mocha 'dispatcher tests' do
-
 class DispatcherTest < Test::Unit::TestCase
   Dispatcher = ActionController::Dispatcher
 
   def setup
     ENV['REQUEST_METHOD'] = 'GET'
 
+    Dispatcher.middleware = ActionDispatch::MiddlewareStack.new do |middleware|
+      middlewares = File.expand_path(File.join(File.dirname(__FILE__), "../../lib/action_controller/dispatch/middlewares.rb"))
+      middleware.instance_eval(File.read(middlewares))
+    end
+
     # Clear callbacks as they are redefined by Dispatcher#define_dispatcher_callbacks
     Dispatcher.instance_variable_set("@prepare_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
     Dispatcher.instance_variable_set("@before_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
     Dispatcher.instance_variable_set("@after_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
 
     Dispatcher.stubs(:require_dependency)
-
-    @dispatcher = Dispatcher.new
   end
 
   def teardown
@@ -67,7 +68,7 @@ class DispatcherTest < Test::Unit::TestCase
     assert_nil a || b || c
 
     # Run callbacks
-    @dispatcher.send :run_callbacks, :prepare_dispatch
+    Dispatcher.run_prepare_callbacks
 
     assert_equal 1, a
     assert_equal 2, b
@@ -84,7 +85,7 @@ class DispatcherTest < Test::Unit::TestCase
     Dispatcher.to_prepare(:unique_id) { |*args| a = b = 1 }
     Dispatcher.to_prepare(:unique_id) { |*args| a = 2 }
 
-    @dispatcher.send :run_callbacks, :prepare_dispatch
+    Dispatcher.run_prepare_callbacks
     assert_equal 2, a
     assert_equal nil, b
   end
@@ -93,12 +94,10 @@ class DispatcherTest < Test::Unit::TestCase
     def dispatch(cache_classes = true)
       ActionController::Routing::RouteSet.any_instance.stubs(:call).returns([200, {}, 'response'])
       Dispatcher.define_dispatcher_callbacks(cache_classes)
-      @dispatcher.call({})
+      Dispatcher.new.call({})
     end
 
     def assert_subclasses(howmany, klass, message = klass.subclasses.inspect)
       assert_equal howmany, klass.subclasses.size, message
     end
 end
-
-end
diff --git a/actionpack/test/controller/fake_models.rb b/actionpack/test/controller/fake_models.rb
index 7420579ed8..0b30c79b10 100644
--- a/actionpack/test/controller/fake_models.rb
+++ b/actionpack/test/controller/fake_models.rb
@@ -9,3 +9,11 @@ end
 
 class GoodCustomer < Customer
 end
+
+module Quiz
+  class Question < Struct.new(:name, :id)
+    def to_param
+      id.to_s
+    end
+  end
+end
diff --git a/actionpack/test/controller/html-scanner/document_test.rb b/actionpack/test/controller/html-scanner/document_test.rb
index 1c3facb9e3..c68f04fa75 100644
--- a/actionpack/test/controller/html-scanner/document_test.rb
+++ b/actionpack/test/controller/html-scanner/document_test.rb
@@ -134,7 +134,7 @@ HTML
   end
 
   def test_invalid_document_raises_exception_when_strict
-    assert_raises RuntimeError do
+    assert_raise RuntimeError do
       doc = HTML::Document.new("<html>
         <table>
           <tr>
diff --git a/actionpack/test/controller/http_digest_authentication_test.rb b/actionpack/test/controller/http_digest_authentication_test.rb
index 59f7a403b5..00789eea38 100644
--- a/actionpack/test/controller/http_digest_authentication_test.rb
+++ b/actionpack/test/controller/http_digest_authentication_test.rb
@@ -5,7 +5,8 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
     before_filter :authenticate, :only => :index
     before_filter :authenticate_with_request, :only => :display
 
-    USERS = { 'lifo' => 'world', 'pretty' => 'please' }
+    USERS = { 'lifo' => 'world', 'pretty' => 'please',
+              'dhh' => ::Digest::MD5::hexdigest(["dhh","SuperSecret","secret"].join(":"))}
 
     def index
       render :text => "Hello Secret"
@@ -107,21 +108,68 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
     assert_equal 'Definitely Maybe', @response.body
   end
 
+  test "authentication request with valid credential and nil session" do
+    @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => 'pretty', :password => 'please')
+
+    # session_id = "" in functional test, but is +nil+ in real life
+    @request.session.session_id = nil
+    get :display
+
+    assert_response :success
+    assert assigns(:logged_in)
+    assert_equal 'Definitely Maybe', @response.body
+  end
+
+   test "authentication request with request-uri that doesn't match credentials digest-uri" do
+    @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => 'pretty', :password => 'please')
+    @request.env['REQUEST_URI'] = "/http_digest_authentication_test/dummy_digest/altered/uri"
+    get :display
+
+    assert_response :unauthorized
+    assert_equal "Authentication Failed", @response.body
+  end
+
+   test "authentication request with absolute uri" do
+    @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:uri => "http://test.host/http_digest_authentication_test/dummy_digest/display",
+                                                            :username => 'pretty', :password => 'please')
+    @request.env['REQUEST_URI'] = "http://test.host/http_digest_authentication_test/dummy_digest/display"
+    get :display
+
+    assert_response :success
+    assert assigns(:logged_in)
+    assert_equal 'Definitely Maybe', @response.body
+  end
+
+  test "authentication request with password stored as ha1 digest hash" do
+    @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => 'dhh',
+                                           :password => ::Digest::MD5::hexdigest(["dhh","SuperSecret","secret"].join(":")),
+                                           :password_is_ha1 => true)
+    get :display
+
+    assert_response :success
+    assert assigns(:logged_in)
+    assert_equal 'Definitely Maybe', @response.body
+  end
+
   private
 
   def encode_credentials(options)
-    options.reverse_merge!(:nc => "00000001", :cnonce => "0a4f113b")
+    options.reverse_merge!(:nc => "00000001", :cnonce => "0a4f113b", :password_is_ha1 => false)
     password = options.delete(:password)
 
-    # Perform unautheticated get to retrieve digest parameters to use on subsequent request
+    # Set in /initializers/session_store.rb. Used as secret in generating nonce
+    # to prevent tampering of timestamp
+    ActionController::Base.session_options[:secret] = "session_options_secret"
+
+    # Perform unauthenticated GET to retrieve digest parameters to use on subsequent request
     get :index
 
     assert_response :unauthorized
 
     credentials = decode_credentials(@response.headers['WWW-Authenticate'])
     credentials.merge!(options)
-    credentials.merge!(:uri => "http://#{@request.host}#{@request.env['REQUEST_URI']}")
-    ActionController::HttpAuthentication::Digest.encode_credentials("GET", credentials, password)
+    credentials.reverse_merge!(:uri => "#{@request.env['REQUEST_URI']}")
+    ActionController::HttpAuthentication::Digest.encode_credentials("GET", credentials, password, options[:password_is_ha1])
   end
 
   def decode_credentials(header)
diff --git a/actionpack/test/controller/integration_test.rb b/actionpack/test/controller/integration_test.rb
index 4f07cbee47..e39a934c24 100644
--- a/actionpack/test/controller/integration_test.rb
+++ b/actionpack/test/controller/integration_test.rb
@@ -1,10 +1,8 @@
 require 'abstract_unit'
 
-uses_mocha 'integration' do
-
 class SessionTest < Test::Unit::TestCase
   StubApp = lambda { |env|
-    [200, {"Content-Type" => "text/html", "Content-Length" => "13"}, "Hello, World!"]
+    [200, {"Content-Type" => "text/html", "Content-Length" => "13"}, ["Hello, World!"]]
   }
 
   def setup
@@ -266,6 +264,7 @@ class IntegrationProcessTest < ActionController::IntegrationTest
       assert_response :success
       assert_response :ok
       assert_equal({}, cookies)
+      assert_equal "OK", body
       assert_equal "OK", response.body
       assert_kind_of HTML::Document, html_document
       assert_equal 1, request_count
@@ -281,6 +280,7 @@ class IntegrationProcessTest < ActionController::IntegrationTest
       assert_response :success
       assert_response :created
       assert_equal({}, cookies)
+      assert_equal "Created", body
       assert_equal "Created", response.body
       assert_kind_of HTML::Document, html_document
       assert_equal 1, request_count
@@ -296,7 +296,7 @@ class IntegrationProcessTest < ActionController::IntegrationTest
       assert_equal "Gone", status_message
       assert_response 410
       assert_response :gone
-      assert_equal ["cookie_1=; path=/", "cookie_3=chocolate; path=/"], headers["Set-Cookie"]
+      assert_equal "cookie_1=; path=/\ncookie_3=chocolate; path=/", headers["Set-Cookie"]
       assert_equal({"cookie_1"=>"", "cookie_2"=>"oatmeal", "cookie_3"=>"chocolate"}, cookies)
       assert_equal "Gone", response.body
     end
@@ -360,6 +360,18 @@ class IntegrationProcessTest < ActionController::IntegrationTest
     end
   end
 
+  def test_head
+    with_test_route_set do
+      head '/get'
+      assert_equal 200, status
+      assert_equal "", body
+
+      head '/post'
+      assert_equal 201, status
+      assert_equal "", body
+    end
+  end
+
   private
     def with_test_route_set
       with_routing do |set|
@@ -377,9 +389,9 @@ class MetalTest < ActionController::IntegrationTest
   class Poller
     def self.call(env)
       if env["PATH_INFO"] =~ /^\/success/
-        [200, {"Content-Type" => "text/plain", "Content-Length" => "12"}, "Hello World!"]
+        [200, {"Content-Type" => "text/plain", "Content-Length" => "12"}, ["Hello World!"]]
       else
-        [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, '']
+        [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []]
       end
     end
   end
@@ -403,5 +415,3 @@ class MetalTest < ActionController::IntegrationTest
     assert_equal '', response.body
   end
 end
-
-end
diff --git a/actionpack/test/controller/layout_test.rb b/actionpack/test/controller/layout_test.rb
index 09283eddc9..f2721e274d 100644
--- a/actionpack/test/controller/layout_test.rb
+++ b/actionpack/test/controller/layout_test.rb
@@ -80,10 +80,21 @@ end
 class DefaultLayoutController < LayoutTest
 end
 
+class AbsolutePathLayoutController < LayoutTest
+  layout File.expand_path(File.expand_path(__FILE__) + '/../../fixtures/layout_tests/layouts/layout_test.rhtml')
+end
+
 class HasOwnLayoutController < LayoutTest
   layout 'item'
 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
@@ -163,6 +174,20 @@ class LayoutSetInResponseTest < ActionController::TestCase
   ensure
     ActionController::Base.exempt_from_layout.delete(/\.rhtml$/)
   end
+
+  def test_layout_is_picked_from_the_controller_instances_view_path
+    pending do
+      @controller = PrependsViewPathController.new
+      get :hello
+      assert_equal 'layouts/alt', @response.layout
+    end
+  end
+
+  def test_absolute_pathed_layout
+    @controller = AbsolutePathLayoutController.new
+    get :hello
+    assert_equal "layout_test.rhtml hello.rhtml", @response.body.strip
+  end
 end
 
 class RenderWithTemplateOptionController < LayoutTest
diff --git a/actionpack/test/controller/mime_responds_test.rb b/actionpack/test/controller/mime_responds_test.rb
index f40a2e04d6..1c81989d9b 100644
--- a/actionpack/test/controller/mime_responds_test.rb
+++ b/actionpack/test/controller/mime_responds_test.rb
@@ -471,7 +471,7 @@ class MimeControllerTest < ActionController::TestCase
     assert_equal '<html><div id="html_missing">Hello future from Firefox!</div></html>', @response.body
 
     @request.accept = "text/iphone"
-    assert_raises(ActionView::MissingTemplate) { get :iphone_with_html_response_type_without_layout }
+    assert_raise(ActionView::MissingTemplate) { get :iphone_with_html_response_type_without_layout }
   end
 end
 
diff --git a/actionpack/test/controller/polymorphic_routes_test.rb b/actionpack/test/controller/polymorphic_routes_test.rb
index 09c7f74617..146d703619 100644
--- a/actionpack/test/controller/polymorphic_routes_test.rb
+++ b/actionpack/test/controller/polymorphic_routes_test.rb
@@ -18,193 +18,276 @@ class Tag < Article
   def response_id; 1 end
 end
 
+class Tax
+  attr_reader :id
+  def save; @id = 1 end
+  def new_record?; @id.nil? end
+  def name
+    model = self.class.name.downcase
+    @id.nil? ? "new #{model}" : "#{model} ##{@id}"
+  end
+end
+
+class Fax < Tax
+  def store_id; 1 end
+end
+
 # TODO: test nested models
 class Response::Nested < Response; end
 
-uses_mocha 'polymorphic URL helpers' do
-  class PolymorphicRoutesTest < ActiveSupport::TestCase
-    include ActionController::PolymorphicRoutes
+class PolymorphicRoutesTest < ActiveSupport::TestCase
+  include ActionController::PolymorphicRoutes
 
-    def setup
-      @article = Article.new
-      @response = Response.new
-    end
-  
-    def test_with_record
-      @article.save
-      expects(:article_url).with(@article)
-      polymorphic_url(@article)
-    end
+  def setup
+    @article = Article.new
+    @response = Response.new
+    @tax = Tax.new
+    @fax = Fax.new
+  end
 
-    def test_with_new_record
-      expects(:articles_url).with()
-      @article.expects(:new_record?).returns(true)
-      polymorphic_url(@article)
-    end
+  def test_with_record
+    @article.save
+    expects(:article_url).with(@article)
+    polymorphic_url(@article)
+  end
 
-    def test_with_record_and_action
-      expects(:new_article_url).with()
-      @article.expects(:new_record?).never
-      polymorphic_url(@article, :action => 'new')
-    end
+  def test_with_new_record
+    expects(:articles_url).with()
+    @article.expects(:new_record?).returns(true)
+    polymorphic_url(@article)
+  end
 
-    def test_url_helper_prefixed_with_new
-      expects(:new_article_url).with()
-      new_polymorphic_url(@article)
-    end
+  def test_with_record_and_action
+    expects(:new_article_url).with()
+    @article.expects(:new_record?).never
+    polymorphic_url(@article, :action => 'new')
+  end
 
-    def test_url_helper_prefixed_with_edit
-      @article.save
-      expects(:edit_article_url).with(@article)
-      edit_polymorphic_url(@article)
-    end
+  def test_url_helper_prefixed_with_new
+    expects(:new_article_url).with()
+    new_polymorphic_url(@article)
+  end
 
-    def test_url_helper_prefixed_with_edit_with_url_options
-      @article.save
-      expects(:edit_article_url).with(@article, :param1 => '10')
-      edit_polymorphic_url(@article, :param1 => '10')
-    end
+  def test_url_helper_prefixed_with_edit
+    @article.save
+    expects(:edit_article_url).with(@article)
+    edit_polymorphic_url(@article)
+  end
 
-    def test_url_helper_with_url_options
-      @article.save
-      expects(:article_url).with(@article, :param1 => '10')
-      polymorphic_url(@article, :param1 => '10')
-    end
+  def test_url_helper_prefixed_with_edit_with_url_options
+    @article.save
+    expects(:edit_article_url).with(@article, :param1 => '10')
+    edit_polymorphic_url(@article, :param1 => '10')
+  end
 
-    def test_formatted_url_helper_is_deprecated
-      expects(:articles_url).with(:format => :pdf)
-      assert_deprecated do
-        formatted_polymorphic_url([@article, :pdf])
-      end
-    end
+  def test_url_helper_with_url_options
+    @article.save
+    expects(:article_url).with(@article, :param1 => '10')
+    polymorphic_url(@article, :param1 => '10')
+  end
 
-    def test_format_option
-      @article.save
-      expects(:article_url).with(@article, :format => :pdf)
-      polymorphic_url(@article, :format => :pdf)
+  def test_formatted_url_helper_is_deprecated
+    expects(:articles_url).with(:format => :pdf)
+    assert_deprecated do
+      formatted_polymorphic_url([@article, :pdf])
     end
+  end
 
-    def test_format_option_with_url_options
-      @article.save
-      expects(:article_url).with(@article, :format => :pdf, :param1 => '10')
-      polymorphic_url(@article, :format => :pdf, :param1 => '10')
-    end
+  def test_format_option
+    @article.save
+    expects(:article_url).with(@article, :format => :pdf)
+    polymorphic_url(@article, :format => :pdf)
+  end
 
-    def test_id_and_format_option
-      @article.save
-      expects(:article_url).with(:id => @article, :format => :pdf)
-      polymorphic_url(:id => @article, :format => :pdf)
-    end
+  def test_format_option_with_url_options
+    @article.save
+    expects(:article_url).with(@article, :format => :pdf, :param1 => '10')
+    polymorphic_url(@article, :format => :pdf, :param1 => '10')
+  end
 
-    def test_with_nested
-      @response.save
-      expects(:article_response_url).with(@article, @response)
-      polymorphic_url([@article, @response])
-    end
+  def test_id_and_format_option
+    @article.save
+    expects(:article_url).with(:id => @article, :format => :pdf)
+    polymorphic_url(:id => @article, :format => :pdf)
+  end
 
-    def test_with_nested_unsaved
-      expects(:article_responses_url).with(@article)
-      polymorphic_url([@article, @response])
-    end
+  def test_with_nested
+    @response.save
+    expects(:article_response_url).with(@article, @response)
+    polymorphic_url([@article, @response])
+  end
 
-    def test_new_with_array_and_namespace
-      expects(:new_admin_article_url).with()
-      polymorphic_url([:admin, @article], :action => 'new')
-    end
+  def test_with_nested_unsaved
+    expects(:article_responses_url).with(@article)
+    polymorphic_url([@article, @response])
+  end
 
-    def test_unsaved_with_array_and_namespace
-      expects(:admin_articles_url).with()
-      polymorphic_url([:admin, @article])
-    end
+  def test_new_with_array_and_namespace
+    expects(:new_admin_article_url).with()
+    polymorphic_url([:admin, @article], :action => 'new')
+  end
 
-    def test_nested_unsaved_with_array_and_namespace
-      @article.save
-      expects(:admin_article_url).with(@article)
-      polymorphic_url([:admin, @article])
-      expects(:admin_article_responses_url).with(@article)
-      polymorphic_url([:admin, @article, @response])
-    end
+  def test_unsaved_with_array_and_namespace
+    expects(:admin_articles_url).with()
+    polymorphic_url([:admin, @article])
+  end
 
-    def test_nested_with_array_and_namespace
-      @response.save
-      expects(:admin_article_response_url).with(@article, @response)
-      polymorphic_url([:admin, @article, @response])
+  def test_nested_unsaved_with_array_and_namespace
+    @article.save
+    expects(:admin_article_url).with(@article)
+    polymorphic_url([:admin, @article])
+    expects(:admin_article_responses_url).with(@article)
+    polymorphic_url([:admin, @article, @response])
+  end
 
-      # a ridiculously long named route tests correct ordering of namespaces and nesting:
-      @tag = Tag.new
-      @tag.save
-      expects(:site_admin_article_response_tag_url).with(@article, @response, @tag)
-      polymorphic_url([:site, :admin, @article, @response, @tag])
-    end
+  def test_nested_with_array_and_namespace
+    @response.save
+    expects(:admin_article_response_url).with(@article, @response)
+    polymorphic_url([:admin, @article, @response])
 
-    def test_nesting_with_array_ending_in_singleton_resource
-      expects(:article_response_url).with(@article)
-      polymorphic_url([@article, :response])
-    end
+    # a ridiculously long named route tests correct ordering of namespaces and nesting:
+    @tag = Tag.new
+    @tag.save
+    expects(:site_admin_article_response_tag_url).with(@article, @response, @tag)
+    polymorphic_url([:site, :admin, @article, @response, @tag])
+  end
 
-    def test_nesting_with_array_containing_singleton_resource
-      @tag = Tag.new
-      @tag.save
-      expects(:article_response_tag_url).with(@article, @tag)
-      polymorphic_url([@article, :response, @tag])
-    end
+  def test_nesting_with_array_ending_in_singleton_resource
+    expects(:article_response_url).with(@article)
+    polymorphic_url([@article, :response])
+  end
 
-    def test_nesting_with_array_containing_namespace_and_singleton_resource
-      @tag = Tag.new
-      @tag.save
-      expects(:admin_article_response_tag_url).with(@article, @tag)
-      polymorphic_url([:admin, @article, :response, @tag])
-    end
+  def test_nesting_with_array_containing_singleton_resource
+    @tag = Tag.new
+    @tag.save
+    expects(:article_response_tag_url).with(@article, @tag)
+    polymorphic_url([@article, :response, @tag])
+  end
 
-    def test_nesting_with_array_containing_singleton_resource_and_format
-      @tag = Tag.new
-      @tag.save
-      expects(:article_response_tag_url).with(@article, @tag, :format => :pdf)
-      polymorphic_url([@article, :response, @tag], :format => :pdf)
-    end
+  def test_nesting_with_array_containing_namespace_and_singleton_resource
+    @tag = Tag.new
+    @tag.save
+    expects(:admin_article_response_tag_url).with(@article, @tag)
+    polymorphic_url([:admin, @article, :response, @tag])
+  end
 
-    def test_nesting_with_array_containing_singleton_resource_and_format_option
-      @tag = Tag.new
-      @tag.save
-      expects(:article_response_tag_url).with(@article, @tag, :format => :pdf)
-      polymorphic_url([@article, :response, @tag], :format => :pdf)
-    end
+  def test_nesting_with_array_containing_singleton_resource_and_format
+    @tag = Tag.new
+    @tag.save
+    expects(:article_response_tag_url).with(@article, @tag, :format => :pdf)
+    polymorphic_url([@article, :response, @tag], :format => :pdf)
+  end
 
-    def test_nesting_with_array_containing_nil
-      expects(:article_response_url).with(@article)
-      polymorphic_url([@article, nil, :response])
-    end
+  def test_nesting_with_array_containing_singleton_resource_and_format_option
+    @tag = Tag.new
+    @tag.save
+    expects(:article_response_tag_url).with(@article, @tag, :format => :pdf)
+    polymorphic_url([@article, :response, @tag], :format => :pdf)
+  end
 
-    def test_with_array_containing_single_object
-      @article.save
-      expects(:article_url).with(@article)
-      polymorphic_url([nil, @article])
-    end
+  def test_nesting_with_array_containing_nil
+    expects(:article_response_url).with(@article)
+    polymorphic_url([@article, nil, :response])
+  end
 
-    def test_with_array_containing_single_name
-      @article.save
-      expects(:articles_url)
-      polymorphic_url([:articles])
-    end
+  def test_with_array_containing_single_object
+    @article.save
+    expects(:article_url).with(@article)
+    polymorphic_url([nil, @article])
+  end
 
-    # TODO: Needs to be updated to correctly know about whether the object is in a hash or not
-    def xtest_with_hash
-      expects(:article_url).with(@article)
-      @article.save
-      polymorphic_url(:id => @article)
-    end
+  def test_with_array_containing_single_name
+    @article.save
+    expects(:articles_url)
+    polymorphic_url([:articles])
+  end
 
-    def test_polymorphic_path_accepts_options
-      expects(:new_article_path).with()
-      polymorphic_path(@article, :action => :new)
-    end
+  # TODO: Needs to be updated to correctly know about whether the object is in a hash or not
+  def xtest_with_hash
+    expects(:article_url).with(@article)
+    @article.save
+    polymorphic_url(:id => @article)
+  end
+
+  def test_polymorphic_path_accepts_options
+    expects(:new_article_path).with()
+    polymorphic_path(@article, :action => :new)
+  end
 
-    def test_polymorphic_path_does_not_modify_arguments
-      expects(:admin_article_responses_url).with(@article)
-      path = [:admin, @article, @response]
-      assert_no_difference 'path.size' do
-        polymorphic_url(path)
-      end
+  def test_polymorphic_path_does_not_modify_arguments
+    expects(:admin_article_responses_url).with(@article)
+    path = [:admin, @article, @response]
+    assert_no_difference 'path.size' do
+      polymorphic_url(path)
     end
   end
+
+  # Tests for names where .plural.singular doesn't round-trip
+  def test_with_irregular_plural_record
+    @tax.save
+    expects(:taxis_url).with(@tax)
+    polymorphic_url(@tax)
+  end
+
+  def test_with_irregular_plural_new_record
+    expects(:taxes_url).with()
+    @tax.expects(:new_record?).returns(true)
+    polymorphic_url(@tax)
+  end
+
+  def test_with_irregular_plural_record_and_action
+    expects(:new_taxis_url).with()
+    @tax.expects(:new_record?).never
+    polymorphic_url(@tax, :action => 'new')
+  end
+
+  def test_irregular_plural_url_helper_prefixed_with_new
+    expects(:new_taxis_url).with()
+    new_polymorphic_url(@tax)
+  end
+
+  def test_irregular_plural_url_helper_prefixed_with_edit
+    @tax.save
+    expects(:edit_taxis_url).with(@tax)
+    edit_polymorphic_url(@tax)
+  end
+
+  def test_with_nested_irregular_plurals
+    @fax.save
+    expects(:taxis_faxis_url).with(@tax, @fax)
+    polymorphic_url([@tax, @fax])
+  end
+
+  def test_with_nested_unsaved_irregular_plurals
+    expects(:taxis_faxes_url).with(@tax)
+    polymorphic_url([@tax, @fax])
+  end
+
+  def test_new_with_irregular_plural_array_and_namespace
+    expects(:new_admin_taxis_url).with()
+    polymorphic_url([:admin, @tax], :action => 'new')
+  end
+
+  def test_unsaved_with_irregular_plural_array_and_namespace
+    expects(:admin_taxes_url).with()
+    polymorphic_url([:admin, @tax])
+  end
+
+  def test_nesting_with_irregular_plurals_and_array_ending_in_singleton_resource
+    expects(:taxis_faxis_url).with(@tax)
+    polymorphic_url([@tax, :faxis])
+  end
+
+  def test_with_array_containing_single_irregular_plural_object
+    @tax.save
+    expects(:taxis_url).with(@tax)
+    polymorphic_url([nil, @tax])
+  end
+
+  def test_with_array_containing_single_name_irregular_plural
+    @tax.save
+    expects(:taxes_url)
+    polymorphic_url([:taxes])
+  end
+
 end
diff --git a/actionpack/test/controller/redirect_test.rb b/actionpack/test/controller/redirect_test.rb
index 27cedc91d2..91e21db854 100644
--- a/actionpack/test/controller/redirect_test.rb
+++ b/actionpack/test/controller/redirect_test.rb
@@ -212,7 +212,7 @@ class RedirectTest < ActionController::TestCase
   end
 
   def test_redirect_to_back_with_no_referer
-    assert_raises(ActionController::RedirectBackError) {
+    assert_raise(ActionController::RedirectBackError) {
       @request.env["HTTP_REFERER"] = nil
       get :redirect_to_back
     }
@@ -239,7 +239,7 @@ class RedirectTest < ActionController::TestCase
   end
 
   def test_redirect_to_nil
-    assert_raises(ActionController::ActionControllerError) do
+    assert_raise(ActionController::ActionControllerError) do
       get :redirect_to_nil
     end
   end
diff --git a/actionpack/test/controller/render_test.rb b/actionpack/test/controller/render_test.rb
index dde49cd136..9a34bcebe6 100644
--- a/actionpack/test/controller/render_test.rb
+++ b/actionpack/test/controller/render_test.rb
@@ -36,6 +36,39 @@ class TestController < ActionController::Base
       render :action => 'hello_world'
     end
   end
+  
+  def conditional_hello_with_public_header
+    if stale?(:last_modified => Time.now.utc.beginning_of_day, :etag => [:foo, 123], :public => true)
+      render :action => 'hello_world'
+    end
+  end
+  
+  def conditional_hello_with_public_header_and_expires_at
+    expires_in 1.minute
+    if stale?(:last_modified => Time.now.utc.beginning_of_day, :etag => [:foo, 123], :public => true)
+      render :action => 'hello_world'
+    end
+  end
+  
+  def conditional_hello_with_expires_in
+    expires_in 1.minute
+    render :action => 'hello_world'
+  end
+  
+  def conditional_hello_with_expires_in_with_public
+    expires_in 1.minute, :public => true
+    render :action => 'hello_world'
+  end
+  
+  def conditional_hello_with_expires_in_with_public_with_more_keys
+    expires_in 1.minute, :public => true, 'max-stale' => 5.hours
+    render :action => 'hello_world'
+  end
+  
+  def conditional_hello_with_expires_in_with_public_with_more_keys_old_syntax
+    expires_in 1.minute, :public => true, :private => nil, 'max-stale' => 5.hours
+    render :action => 'hello_world'
+  end
 
   def conditional_hello_with_bangs
     render :action => 'hello_world'
@@ -124,6 +157,11 @@ class TestController < ActionController::Base
     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.erb')
+  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.erb'))
@@ -642,6 +680,14 @@ class TestController < ActionController::Base
     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
@@ -686,6 +732,8 @@ class TestController < ActionController::Base
           "layouts/standard"
         when "action_talk_to_layout", "layout_overriding_layout"
           "layouts/talk_from_action"
+        when "render_implicit_html_template_from_xhr_request"
+          (request.xhr? ? 'layouts/xhr' : 'layouts/standard')
       end
     end
 end
@@ -805,6 +853,11 @@ class RenderTest < ActionController::TestCase
     assert_equal "The secret is in the sauce\n", @response.body
   end
 
+  def test_render_file_using_pathname
+    get :render_file_using_pathname
+    assert_equal "The secret is in the sauce\n", @response.body
+  end
+
   def test_render_file_with_locals
     get :render_file_with_locals
     assert_equal "The secret is in the sauce\n", @response.body
@@ -881,11 +934,11 @@ class RenderTest < ActionController::TestCase
   end
 
   def test_attempt_to_access_object_method
-    assert_raises(ActionController::UnknownAction, "No action responded to [clone]") { get :clone }
+    assert_raise(ActionController::UnknownAction, "No action responded to [clone]") { get :clone }
   end
 
   def test_private_methods
-    assert_raises(ActionController::UnknownAction, "No action responded to [determine_layout]") { get :determine_layout }
+    assert_raise(ActionController::UnknownAction, "No action responded to [determine_layout]") { get :determine_layout }
   end
 
   def test_access_to_request_in_view
@@ -1016,8 +1069,15 @@ class RenderTest < ActionController::TestCase
 
   def test_should_implicitly_render_html_template_from_xhr_request
     pending do
-      get :render_implicit_html_template_from_xhr_request, :format => :js
-      assert_equal "Hello HTML!", @response.body
+      xhr :get, :render_implicit_html_template_from_xhr_request
+      assert_equal "XHR!\nHello HTML!", @response.body
+    end
+  end
+
+  def test_should_implicitly_render_js_template_without_layout
+    pending do
+      get :render_implicit_js_template_without_layout, :format => :js
+      assert_no_match %r{<html>}, @response.body
     end
   end
 
@@ -1109,7 +1169,7 @@ class RenderTest < ActionController::TestCase
   end
 
   def test_bad_render_to_string_still_throws_exception
-    assert_raises(ActionView::MissingTemplate) { get :render_to_string_with_exception }
+    assert_raise(ActionView::MissingTemplate) { get :render_to_string_with_exception }
   end
 
   def test_render_to_string_that_throws_caught_exception_doesnt_break_assigns
@@ -1134,15 +1194,15 @@ class RenderTest < ActionController::TestCase
   end
 
   def test_double_render
-    assert_raises(ActionController::DoubleRenderError) { get :double_render }
+    assert_raise(ActionController::DoubleRenderError) { get :double_render }
   end
 
   def test_double_redirect
-    assert_raises(ActionController::DoubleRenderError) { get :double_redirect }
+    assert_raise(ActionController::DoubleRenderError) { get :double_redirect }
   end
 
   def test_render_and_redirect
-    assert_raises(ActionController::DoubleRenderError) { get :render_and_redirect }
+    assert_raise(ActionController::DoubleRenderError) { get :render_and_redirect }
   end
 
   # specify the one exception to double render rule - render_to_string followed by render
@@ -1423,6 +1483,16 @@ class RenderTest < ActionController::TestCase
     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
@@ -1441,7 +1511,7 @@ class RenderTest < ActionController::TestCase
   end
 
   def test_render_missing_partial_template
-    assert_raises(ActionView::MissingTemplate) do
+    assert_raise(ActionView::MissingTemplate) do
       get :missing_partial
     end
   end
@@ -1457,6 +1527,35 @@ class RenderTest < ActionController::TestCase
   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"]
+  end
+  
+  def test_expires_in_header_with_public
+    get :conditional_hello_with_expires_in_with_public
+    assert_equal "max-age=60, public", @response.headers["Cache-Control"]
+  end
+  
+  def test_expires_in_header_with_additional_headers
+    get :conditional_hello_with_expires_in_with_public_with_more_keys
+    assert_equal "max-age=60, public, max-stale=18000", @response.headers["Cache-Control"]
+  end
+  
+  def test_expires_in_old_syntax
+    get :conditional_hello_with_expires_in_with_public_with_more_keys_old_syntax
+    assert_equal "max-age=60, public, max-stale=18000", @response.headers["Cache-Control"]
+  end
+end
+
+
 class EtagRenderTest < ActionController::TestCase
   tests TestController
 
@@ -1547,6 +1646,16 @@ class EtagRenderTest < ActionController::TestCase
     get :conditional_hello_with_bangs
     assert_response :not_modified
   end
+  
+  def test_etag_with_public_true_should_set_header
+    get :conditional_hello_with_public_header
+    assert_equal "public", @response.headers['Cache-Control']
+  end
+  
+  def test_etag_with_public_true_should_set_header_and_retain_other_headers
+    get :conditional_hello_with_public_header_and_expires_at
+    assert_equal "max-age=60, public", @response.headers['Cache-Control']
+  end
 
   protected
     def etag_for(text)
diff --git a/actionpack/test/controller/request/test_request_test.rb b/actionpack/test/controller/request/test_request_test.rb
new file mode 100644
index 0000000000..81551b4ba7
--- /dev/null
+++ b/actionpack/test/controller/request/test_request_test.rb
@@ -0,0 +1,35 @@
+require 'abstract_unit'
+require 'stringio'
+
+class ActionController::TestRequestTest < ActiveSupport::TestCase
+
+  def setup
+    @request = ActionController::TestRequest.new
+  end
+
+  def test_test_request_has_session_options_initialized
+    assert @request.session_options
+  end
+  
+  Rack::Session::Abstract::ID::DEFAULT_OPTIONS.each_key do |option|
+    test "test_rack_default_session_options_#{option}_exists_in_session_options_and_is_default" do
+      assert_equal(Rack::Session::Abstract::ID::DEFAULT_OPTIONS[option], 
+                   @request.session_options[option], 
+                   "Missing rack session default option #{option} in request.session_options")
+    end
+    test "test_rack_default_session_options_#{option}_exists_in_session_options" do
+      assert(@request.session_options.has_key?(option), 
+                   "Missing rack session option #{option} in request.session_options")
+    end
+  end
+  
+  def test_session_id_exists_by_default
+    assert_not_nil(@request.session_options[:id])
+  end
+  
+  def test_session_id_different_on_each_call
+    prev_id = 
+    assert_not_equal(@request.session_options[:id], ActionController::TestRequest.new.session_options[:id])
+  end
+  
+end
\ No newline at end of file
diff --git a/actionpack/test/controller/request_forgery_protection_test.rb b/actionpack/test/controller/request_forgery_protection_test.rb
index ef0bf5fd08..835e73e3ab 100644
--- a/actionpack/test/controller/request_forgery_protection_test.rb
+++ b/actionpack/test/controller/request_forgery_protection_test.rb
@@ -79,17 +79,17 @@ module RequestForgeryProtectionTests
 
   def test_should_not_allow_html_post_without_token
     @request.env['CONTENT_TYPE'] = Mime::URL_ENCODED_FORM.to_s
-    assert_raises(ActionController::InvalidAuthenticityToken) { post :index, :format => :html }
+    assert_raise(ActionController::InvalidAuthenticityToken) { post :index, :format => :html }
   end
   
   def test_should_not_allow_html_put_without_token
     @request.env['CONTENT_TYPE'] = Mime::URL_ENCODED_FORM.to_s
-    assert_raises(ActionController::InvalidAuthenticityToken) { put :index, :format => :html }
+    assert_raise(ActionController::InvalidAuthenticityToken) { put :index, :format => :html }
   end
   
   def test_should_not_allow_html_delete_without_token
     @request.env['CONTENT_TYPE'] = Mime::URL_ENCODED_FORM.to_s
-    assert_raises(ActionController::InvalidAuthenticityToken) { delete :index, :format => :html }
+    assert_raise(ActionController::InvalidAuthenticityToken) { delete :index, :format => :html }
   end
 
   def test_should_allow_api_formatted_post_without_token
@@ -111,42 +111,42 @@ module RequestForgeryProtectionTests
   end
 
   def test_should_not_allow_api_formatted_post_sent_as_url_encoded_form_without_token
-    assert_raises(ActionController::InvalidAuthenticityToken) do
+    assert_raise(ActionController::InvalidAuthenticityToken) do
       @request.env['CONTENT_TYPE'] = Mime::URL_ENCODED_FORM.to_s
       post :index, :format => 'xml'
     end
   end
 
   def test_should_not_allow_api_formatted_put_sent_as_url_encoded_form_without_token
-    assert_raises(ActionController::InvalidAuthenticityToken) do
+    assert_raise(ActionController::InvalidAuthenticityToken) do
       @request.env['CONTENT_TYPE'] = Mime::URL_ENCODED_FORM.to_s
       put :index, :format => 'xml'
     end
   end
 
   def test_should_not_allow_api_formatted_delete_sent_as_url_encoded_form_without_token
-    assert_raises(ActionController::InvalidAuthenticityToken) do
+    assert_raise(ActionController::InvalidAuthenticityToken) do
       @request.env['CONTENT_TYPE'] = Mime::URL_ENCODED_FORM.to_s
       delete :index, :format => 'xml'
     end
   end
 
   def test_should_not_allow_api_formatted_post_sent_as_multipart_form_without_token
-    assert_raises(ActionController::InvalidAuthenticityToken) do
+    assert_raise(ActionController::InvalidAuthenticityToken) do
       @request.env['CONTENT_TYPE'] = Mime::MULTIPART_FORM.to_s
       post :index, :format => 'xml'
     end
   end
 
   def test_should_not_allow_api_formatted_put_sent_as_multipart_form_without_token
-    assert_raises(ActionController::InvalidAuthenticityToken) do
+    assert_raise(ActionController::InvalidAuthenticityToken) do
       @request.env['CONTENT_TYPE'] = Mime::MULTIPART_FORM.to_s
       put :index, :format => 'xml'
     end
   end
 
   def test_should_not_allow_api_formatted_delete_sent_as_multipart_form_without_token
-    assert_raises(ActionController::InvalidAuthenticityToken) do
+    assert_raise(ActionController::InvalidAuthenticityToken) do
       @request.env['CONTENT_TYPE'] = Mime::MULTIPART_FORM.to_s
       delete :index, :format => 'xml'
     end
diff --git a/actionpack/test/controller/rescue_test.rb b/actionpack/test/controller/rescue_test.rb
index 744ca9286c..741b01caa8 100644
--- a/actionpack/test/controller/rescue_test.rb
+++ b/actionpack/test/controller/rescue_test.rb
@@ -1,7 +1,5 @@
 require 'abstract_unit'
 
-uses_mocha 'rescue' do
-
 class RescueController < ActionController::Base
   class NotAuthorized < StandardError
   end
@@ -202,6 +200,24 @@ class RescueControllerTest < ActionController::TestCase
     end
   end
 
+  def test_rescue_action_in_public_with_localized_error_file
+    # Change locale
+    old_locale = I18n.locale
+    I18n.locale = :da
+
+    with_rails_root FIXTURE_PUBLIC do
+      with_all_requests_local false do
+        get :raises
+      end
+    end
+
+    assert_response :internal_server_error
+    body = File.read("#{FIXTURE_PUBLIC}/public/500.da.html")
+    assert_equal body, @response.body
+  ensure
+    I18n.locale = old_locale
+  end
+
   def test_rescue_action_in_public_with_error_file
     with_rails_root FIXTURE_PUBLIC do
       with_all_requests_local false do
@@ -521,4 +537,3 @@ class ControllerInheritanceRescueControllerTest < ActionController::TestCase
     assert_response :created
   end
 end
-end # uses_mocha
diff --git a/actionpack/test/controller/resources_test.rb b/actionpack/test/controller/resources_test.rb
index 8dedeb23f6..c807e71cd7 100644
--- a/actionpack/test/controller/resources_test.rb
+++ b/actionpack/test/controller/resources_test.rb
@@ -99,7 +99,7 @@ class ResourcesTest < ActionController::TestCase
     expected_options = {:controller => 'messages', :action => 'show', :id => '1.1.1'}
 
     with_restful_routing :messages do
-      assert_raises(ActionController::RoutingError) do
+      assert_raise(ActionController::RoutingError) do
         assert_recognizes(expected_options, :path => 'messages/1.1.1', :method => :get)
       end
     end
@@ -175,6 +175,24 @@ class ResourcesTest < ActionController::TestCase
     end
   end
 
+  def test_with_collection_actions_and_name_prefix_and_member_action_with_same_name
+    actions = { 'a' => :get }
+
+    with_restful_routing :messages, :path_prefix => '/threads/:thread_id', :name_prefix => "thread_", :collection => actions, :member => actions do
+      assert_restful_routes_for :messages, :path_prefix => 'threads/1/', :name_prefix => 'thread_', :options => { :thread_id => '1' } do |options|
+        actions.each do |action, method|
+          assert_recognizes(options.merge(:action => action), :path => "/threads/1/messages/#{action}", :method => method)
+        end
+      end
+
+      assert_restful_named_routes_for :messages, :path_prefix => 'threads/1/', :name_prefix => 'thread_', :options => { :thread_id => '1' } do |options|
+        actions.keys.each do |action|
+          assert_named_route "/threads/1/messages/#{action}", "#{action}_thread_messages_path", :action => action
+        end
+      end
+    end
+  end
+
   def test_with_collection_action_and_name_prefix_and_formatted
     actions = { 'a' => :get, 'b' => :put, 'c' => :post, 'd' => :delete }
 
@@ -209,6 +227,14 @@ class ResourcesTest < ActionController::TestCase
     end
   end
 
+  def test_with_member_action_and_requirement
+    expected_options = {:controller => 'messages', :action => 'mark', :id => '1.1.1'}
+  
+    with_restful_routing(:messages, :requirements => {:id => /[0-9]\.[0-9]\.[0-9]/}, :member => { :mark => :get }) do
+      assert_recognizes(expected_options, :path => 'messages/1.1.1/mark', :method => :get)
+    end
+  end
+
   def test_member_when_override_paths_for_default_restful_actions_with
     [:put, :post].each do |method|
       with_restful_routing :messages, :member => { :mark => method }, :path_names => {:new => 'nuevo'} do
@@ -325,7 +351,7 @@ class ResourcesTest < ActionController::TestCase
     with_restful_routing :messages do
       assert_restful_routes_for :messages do |options|
         assert_recognizes(options.merge(:action => "new"), :path => "/messages/new", :method => :get)
-        assert_raises(ActionController::MethodNotAllowed) do
+        assert_raise(ActionController::MethodNotAllowed) do
           ActionController::Routing::Routes.recognize_path("/messages/new", :method => :post)
         end
       end
@@ -406,6 +432,34 @@ class ResourcesTest < ActionController::TestCase
     end
   end
 
+  def test_shallow_nested_restful_routes_with_namespaces
+    with_routing do |set|
+      set.draw do |map|
+        map.namespace :backoffice do |map|
+          map.namespace :admin do |map|
+            map.resources :products, :shallow => true do |map|
+              map.resources :images
+            end
+          end
+        end
+      end
+
+      assert_simply_restful_for :products,
+        :controller => 'backoffice/admin/products',
+        :namespace => 'backoffice/admin/',
+        :name_prefix => 'backoffice_admin_',
+        :path_prefix => 'backoffice/admin/',
+        :shallow => true
+      assert_simply_restful_for :images,
+        :controller => 'backoffice/admin/images',
+        :namespace => 'backoffice/admin/',
+        :name_prefix => 'backoffice_admin_product_',
+        :path_prefix => 'backoffice/admin/products/1/',
+        :shallow => true,
+        :options => { :product_id => '1' }
+    end
+  end
+
   def test_restful_routes_dont_generate_duplicates
     with_restful_routing :messages do
       routes = ActionController::Routing::Routes.routes
@@ -583,11 +637,11 @@ class ResourcesTest < ActionController::TestCase
       options = { :controller => controller_name.to_s }
       collection_path = "/#{controller_name}"
 
-      assert_raises(ActionController::MethodNotAllowed) do
+      assert_raise(ActionController::MethodNotAllowed) do
         assert_recognizes(options.merge(:action => 'update'), :path => collection_path, :method => :put)
       end
 
-      assert_raises(ActionController::MethodNotAllowed) do
+      assert_raise(ActionController::MethodNotAllowed) do
         assert_recognizes(options.merge(:action => 'destroy'), :path => collection_path, :method => :delete)
       end
     end
@@ -596,7 +650,7 @@ class ResourcesTest < ActionController::TestCase
   def test_should_not_allow_invalid_head_method_for_member_routes
     with_routing do |set|
       set.draw do |map|
-        assert_raises(ArgumentError) do
+        assert_raise(ArgumentError) do
           map.resources :messages, :member => {:something => :head}
         end
       end
@@ -606,7 +660,7 @@ class ResourcesTest < ActionController::TestCase
   def test_should_not_allow_invalid_http_methods_for_member_routes
     with_routing do |set|
       set.draw do |map|
-        assert_raises(ArgumentError) do
+        assert_raise(ArgumentError) do
           map.resources :messages, :member => {:something => :invalid}
         end
       end
@@ -750,9 +804,17 @@ class ResourcesTest < ActionController::TestCase
   end
 
   def test_with_path_segment
-    with_restful_routing :messages, :as => 'reviews' do
-      assert_simply_restful_for :messages, :as => 'reviews'
+    with_restful_routing :messages do
+      assert_simply_restful_for :messages
+      assert_recognizes({:controller => "messages", :action => "index"}, "/messages")
+      assert_recognizes({:controller => "messages", :action => "index"}, "/messages/")
     end
+
+     with_restful_routing :messages, :as => 'reviews' do
+       assert_simply_restful_for :messages, :as => 'reviews'
+      assert_recognizes({:controller => "messages", :action => "index"}, "/reviews")
+      assert_recognizes({:controller => "messages", :action => "index"}, "/reviews/")
+     end
   end
 
   def test_multiple_with_path_segment_and_controller
@@ -942,19 +1004,6 @@ class ResourcesTest < ActionController::TestCase
     end
   end
 
-  def test_nested_resource_inherits_only_show_action
-    with_routing do |set|
-      set.draw do |map|
-        map.resources :products, :only => :show do |product|
-          product.resources :images
-        end
-      end
-
-      assert_resource_allowed_routes('images', { :product_id => '1' },                    { :id => '2' }, :show, [:index, :new, :create, :edit, :update, :destroy], 'products/1/images')
-      assert_resource_allowed_routes('images', { :product_id => '1', :format => 'xml' },  { :id => '2' }, :show, [:index, :new, :create, :edit, :update, :destroy], 'products/1/images')
-    end
-  end
-
   def test_nested_resource_has_only_show_and_member_action
     with_routing do |set|
       set.draw do |map|
@@ -971,7 +1020,7 @@ class ResourcesTest < ActionController::TestCase
     end
   end
 
-  def test_nested_resource_ignores_only_option
+  def test_nested_resource_does_not_inherit_only_option
     with_routing do |set|
       set.draw do |map|
         map.resources :products, :only => :show do |product|
@@ -984,7 +1033,20 @@ class ResourcesTest < ActionController::TestCase
     end
   end
 
-  def test_nested_resource_ignores_except_option
+  def test_nested_resource_does_not_inherit_only_option_by_default
+    with_routing do |set|
+      set.draw do |map|
+        map.resources :products, :only => :show do |product|
+          product.resources :images
+        end
+      end
+
+      assert_resource_allowed_routes('images', { :product_id => '1' },                    { :id => '2' }, [:index, :new, :create, :show, :edit, :update, :destory], [], 'products/1/images')
+      assert_resource_allowed_routes('images', { :product_id => '1', :format => 'xml' },  { :id => '2' }, [:index, :new, :create, :show, :edit, :update, :destroy], [], 'products/1/images')
+    end
+  end
+
+  def test_nested_resource_does_not_inherit_except_option
     with_routing do |set|
       set.draw do |map|
         map.resources :products, :except => :show do |product|
@@ -997,6 +1059,19 @@ class ResourcesTest < ActionController::TestCase
     end
   end
 
+  def test_nested_resource_does_not_inherit_except_option_by_default
+    with_routing do |set|
+      set.draw do |map|
+        map.resources :products, :except => :show do |product|
+          product.resources :images
+        end
+      end
+
+      assert_resource_allowed_routes('images', { :product_id => '1' },                    { :id => '2' }, [:index, :new, :create, :show, :edit, :update, :destroy], [], 'products/1/images')
+      assert_resource_allowed_routes('images', { :product_id => '1', :format => 'xml' },  { :id => '2' }, [:index, :new, :create, :show, :edit, :update, :destroy], [], 'products/1/images')
+    end
+  end
+
   def test_default_singleton_restful_route_uses_get
     with_routing do |set|
       set.draw do |map|
@@ -1053,7 +1128,7 @@ class ResourcesTest < ActionController::TestCase
 
       path                       = "#{options[:as] || controller_name}"
       collection_path            = "/#{options[:path_prefix]}#{path}"
-      shallow_path               = "/#{options[:path_prefix] unless options[:shallow]}#{path}"
+      shallow_path               = "/#{options[:shallow] ? options[:namespace] : options[:path_prefix]}#{path}"
       member_path                = "#{shallow_path}/1"
       new_path                   = "#{collection_path}/#{new_action}"
       edit_member_path           = "#{member_path}/#{edit_action}"
@@ -1117,10 +1192,10 @@ class ResourcesTest < ActionController::TestCase
       options[:options].delete :action
 
       path = "#{options[:as] || controller_name}"
-      shallow_path = "/#{options[:path_prefix] unless options[:shallow]}#{path}"
+      shallow_path = "/#{options[:shallow] ? options[:namespace] : options[:path_prefix]}#{path}"
       full_path = "/#{options[:path_prefix]}#{path}"
       name_prefix = options[:name_prefix]
-      shallow_prefix = "#{options[:name_prefix] unless options[:shallow]}"
+      shallow_prefix = options[:shallow] ? options[:namespace].try(:gsub, /\//, '_') : options[:name_prefix]
 
       new_action  = "new"
       edit_action = "edit"
diff --git a/actionpack/test/controller/routing_test.rb b/actionpack/test/controller/routing_test.rb
index b981119e1e..ef56119751 100644
--- a/actionpack/test/controller/routing_test.rb
+++ b/actionpack/test/controller/routing_test.rb
@@ -219,7 +219,7 @@ class DynamicSegmentTest < Test::Unit::TestCase
     a_value = nil
 
     # Local jump because of return inside eval.
-    assert_raises(LocalJumpError) { eval(segment.extraction_code) }
+    assert_raise(LocalJumpError) { eval(segment.extraction_code) }
   end
 
   def test_extraction_code_should_return_on_mismatch
@@ -229,7 +229,7 @@ class DynamicSegmentTest < Test::Unit::TestCase
     a_value = nil
 
     # Local jump because of return inside eval.
-    assert_raises(LocalJumpError) { eval(segment.extraction_code) }
+    assert_raise(LocalJumpError) { eval(segment.extraction_code) }
   end
 
   def test_extraction_code_should_accept_value_and_set_local
@@ -340,6 +340,30 @@ class ControllerSegmentTest < Test::Unit::TestCase
   end
 end
 
+class PathSegmentTest < Test::Unit::TestCase
+  def segment(options = {})
+    unless @segment
+      @segment = ROUTING::PathSegment.new(:path, options)
+    end
+    @segment
+  end
+
+  def test_regexp_chunk_should_return_string
+    segment = segment(:regexp => /[a-z]+/)
+    assert_kind_of String, segment.regexp_chunk
+  end
+
+  def test_regexp_chunk_should_be_wrapped_with_parenthesis
+    segment = segment(:regexp => /[a-z]+/)
+    assert_equal "([a-z]+)", segment.regexp_chunk
+  end
+
+  def test_regexp_chunk_should_respect_options
+    segment = segment(:regexp => /[a-z]+/i)
+    assert_equal "((?i-mx:[a-z]+))", segment.regexp_chunk
+  end
+end
+
 class RouteBuilderTest < Test::Unit::TestCase
   def builder
     @builder ||= ROUTING::RouteBuilder.new
@@ -470,7 +494,7 @@ class RouteBuilderTest < Test::Unit::TestCase
     defaults = {:action => 'buy', :person => nil, :car => nil}
     requirements = {:person => /\w+/, :car => /^\w+$/}
 
-    assert_raises ArgumentError do
+    assert_raise ArgumentError do
       route_requirements = builder.assign_route_options(segments, defaults, requirements)
     end
 
@@ -691,1635 +715,1656 @@ class RoutingTest < Test::Unit::TestCase
   end
 end
 
-uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
-  class MockController
-    attr_accessor :routes
-
-    def initialize(routes)
-      self.routes = routes
-    end
+class MockController
+  attr_accessor :routes
 
-    def url_for(options)
-      only_path = options.delete(:only_path)
+  def initialize(routes)
+    self.routes = routes
+  end
 
-      port        = options.delete(:port) || 80
-      port_string = port == 80 ? '' : ":#{port}"
+  def url_for(options)
+    only_path = options.delete(:only_path)
 
-      protocol = options.delete(:protocol) || "http"
-      host     = options.delete(:host) || "test.host"
-      anchor   = "##{options.delete(:anchor)}" if options.key?(:anchor)
+    port        = options.delete(:port) || 80
+    port_string = port == 80 ? '' : ":#{port}"
 
-      path = routes.generate(options)
+    protocol = options.delete(:protocol) || "http"
+    host     = options.delete(:host) || "test.host"
+    anchor   = "##{options.delete(:anchor)}" if options.key?(:anchor)
 
-      only_path ? "#{path}#{anchor}" : "#{protocol}://#{host}#{port_string}#{path}#{anchor}"
-    end
+    path = routes.generate(options)
 
-    def request
-      @request ||= ActionController::TestRequest.new
-    end
+    only_path ? "#{path}#{anchor}" : "#{protocol}://#{host}#{port_string}#{path}#{anchor}"
   end
 
-  class LegacyRouteSetTests < Test::Unit::TestCase
-    attr_reader :rs
+  def request
+    @request ||= ActionController::TestRequest.new
+  end
+end
 
-    def setup
-      # These tests assume optimisation is on, so re-enable it.
-      ActionController::Base.optimise_named_routes = true
+class LegacyRouteSetTests < Test::Unit::TestCase
+  attr_reader :rs
 
-      @rs = ::ActionController::Routing::RouteSet.new
+  def setup
+    # These tests assume optimisation is on, so re-enable it.
+    ActionController::Base.optimise_named_routes = true
+
+    @rs = ::ActionController::Routing::RouteSet.new
+
+    ActionController::Routing.use_controllers! %w(content admin/user admin/news_feed)
+  end
+  
+  def teardown
+    @rs.clear!
+  end
+
+  def test_default_setup
+    @rs.draw {|m| m.connect ':controller/:action/:id' }
+    assert_equal({:controller => "content", :action => 'index'}, rs.recognize_path("/content"))
+    assert_equal({:controller => "content", :action => 'list'}, rs.recognize_path("/content/list"))
+    assert_equal({:controller => "content", :action => 'show', :id => '10'}, rs.recognize_path("/content/show/10"))
+
+    assert_equal({:controller => "admin/user", :action => 'show', :id => '10'}, rs.recognize_path("/admin/user/show/10"))
+
+    assert_equal '/admin/user/show/10', rs.generate(:controller => 'admin/user', :action => 'show', :id => 10)
+
+    assert_equal '/admin/user/show', rs.generate({:action => 'show'}, {:controller => 'admin/user', :action => 'list', :id => '10'})
+    assert_equal '/admin/user/list/10', rs.generate({}, {:controller => 'admin/user', :action => 'list', :id => '10'})
+
+    assert_equal '/admin/stuff', rs.generate({:controller => 'stuff'}, {:controller => 'admin/user', :action => 'list', :id => '10'})
+    assert_equal '/stuff', rs.generate({:controller => '/stuff'}, {:controller => 'admin/user', :action => 'list', :id => '10'})
+  end
+
+  def test_ignores_leading_slash
+    @rs.clear!
+    @rs.draw {|m| m.connect '/:controller/:action/:id'}
+    test_default_setup
+  end
+
+  def test_time_recognition
+    # We create many routes to make situation more realistic
+    @rs = ::ActionController::Routing::RouteSet.new
+    @rs.draw { |map|
+      map.frontpage '', :controller => 'search', :action => 'new'
+      map.resources :videos do |video|
+        video.resources :comments
+        video.resource  :file,      :controller => 'video_file'
+        video.resource  :share,     :controller => 'video_shares'
+        video.resource  :abuse,     :controller => 'video_abuses'
+      end
+      map.resources :abuses, :controller => 'video_abuses'
+      map.resources :video_uploads
+      map.resources :video_visits
+
+      map.resources :users do |user|
+        user.resource  :settings
+        user.resources :videos
+      end
+      map.resources :channels do |channel|
+        channel.resources :videos, :controller => 'channel_videos'
+      end
+      map.resource  :session
+      map.resource  :lost_password
+      map.search    'search', :controller => 'search'
+      map.resources :pages
+      map.connect ':controller/:action/:id'
+    }
+    n = 1000
+    if RunTimeTests
+      GC.start
+      rectime = Benchmark.realtime do
+        n.times do
+          rs.recognize_path("/videos/1234567", {:method => :get})
+          rs.recognize_path("/videos/1234567/abuse", {:method => :get})
+          rs.recognize_path("/users/1234567/settings", {:method => :get})
+          rs.recognize_path("/channels/1234567", {:method => :get})
+          rs.recognize_path("/session/new", {:method => :get})
+          rs.recognize_path("/admin/user/show/10", {:method => :get})
+        end
+      end
+      puts "\n\nRecognition (#{rs.routes.size} routes):"
+      per_url = rectime / (n * 6)
+      puts "#{per_url * 1000} ms/url"
+      puts "#{1 / per_url} url/s\n\n"
+    end
+  end
+
+  def test_time_generation
+    n = 5000
+    if RunTimeTests
+      GC.start
+      pairs = [
+        [{:controller => 'content', :action => 'index'}, {:controller => 'content', :action => 'show'}],
+        [{:controller => 'content'}, {:controller => 'content', :action => 'index'}],
+        [{:controller => 'content', :action => 'list'}, {:controller => 'content', :action => 'index'}],
+        [{:controller => 'content', :action => 'show', :id => '10'}, {:controller => 'content', :action => 'list'}],
+        [{:controller => 'admin/user', :action => 'index'}, {:controller => 'admin/user', :action => 'show'}],
+        [{:controller => 'admin/user'}, {:controller => 'admin/user', :action => 'index'}],
+        [{:controller => 'admin/user', :action => 'list'}, {:controller => 'admin/user', :action => 'index'}],
+        [{:controller => 'admin/user', :action => 'show', :id => '10'}, {:controller => 'admin/user', :action => 'list'}],
+      ]
+      p = nil
+      gentime = Benchmark.realtime do
+        n.times do
+        pairs.each {|(a, b)| rs.generate(a, b)}
+        end
+      end
 
-      ActionController::Routing.use_controllers! %w(content admin/user admin/news_feed)
+      puts "\n\nGeneration (RouteSet): (#{(n * 8)} urls)"
+      per_url = gentime / (n * 8)
+      puts "#{per_url * 1000} ms/url"
+      puts "#{1 / per_url} url/s\n\n"
     end
-    
-    def teardown
-      @rs.clear!
-    end
-
-    def test_default_setup
-      @rs.draw {|m| m.connect ':controller/:action/:id' }
-      assert_equal({:controller => "content", :action => 'index'}, rs.recognize_path("/content"))
-      assert_equal({:controller => "content", :action => 'list'}, rs.recognize_path("/content/list"))
-      assert_equal({:controller => "content", :action => 'show', :id => '10'}, rs.recognize_path("/content/show/10"))
-
-      assert_equal({:controller => "admin/user", :action => 'show', :id => '10'}, rs.recognize_path("/admin/user/show/10"))
+  end
 
-      assert_equal '/admin/user/show/10', rs.generate(:controller => 'admin/user', :action => 'show', :id => 10)
+  def test_route_with_colon_first
+    rs.draw do |map|
+      map.connect '/:controller/:action/:id', :action => 'index', :id => nil
+      map.connect ':url', :controller => 'tiny_url', :action => 'translate'
+    end
+  end
 
-      assert_equal '/admin/user/show', rs.generate({:action => 'show'}, {:controller => 'admin/user', :action => 'list', :id => '10'})
-      assert_equal '/admin/user/list/10', rs.generate({}, {:controller => 'admin/user', :action => 'list', :id => '10'})
+  def test_route_with_regexp_for_controller
+    rs.draw do |map|
+      map.connect ':controller/:admintoken/:action/:id', :controller => /admin\/.+/
+      map.connect ':controller/:action/:id'
+    end
+    assert_equal({:controller => "admin/user", :admintoken => "foo", :action => "index"},
+        rs.recognize_path("/admin/user/foo"))
+    assert_equal({:controller => "content", :action => "foo"}, rs.recognize_path("/content/foo"))
+    assert_equal '/admin/user/foo', rs.generate(:controller => "admin/user", :admintoken => "foo", :action => "index")
+    assert_equal '/content/foo', rs.generate(:controller => "content", :action => "foo")
+  end
 
-      assert_equal '/admin/stuff', rs.generate({:controller => 'stuff'}, {:controller => 'admin/user', :action => 'list', :id => '10'})
-      assert_equal '/stuff', rs.generate({:controller => '/stuff'}, {:controller => 'admin/user', :action => 'list', :id => '10'})
+  def test_route_with_regexp_and_captures_for_controller
+    rs.draw do |map|
+      map.connect ':controller/:action/:id', :controller => /admin\/(accounts|users)/
     end
+    assert_equal({:controller => "admin/accounts", :action => "index"}, rs.recognize_path("/admin/accounts"))
+    assert_equal({:controller => "admin/users", :action => "index"}, rs.recognize_path("/admin/users"))
+    assert_raise(ActionController::RoutingError) { rs.recognize_path("/admin/products") }
+  end
 
-    def test_ignores_leading_slash
-      @rs.clear!
-      @rs.draw {|m| m.connect '/:controller/:action/:id'}
-      test_default_setup
+  def test_route_with_regexp_and_dot
+    rs.draw do |map|
+      map.connect ':controller/:action/:file',
+                        :controller => /admin|user/,
+                        :action => /upload|download/,
+                        :defaults => {:file => nil},
+                        :requirements => {:file => %r{[^/]+(\.[^/]+)?}}
     end
+    # Without a file extension
+    assert_equal '/user/download/file',
+      rs.generate(:controller => "user", :action => "download", :file => "file")
+    assert_equal(
+      {:controller => "user", :action => "download", :file => "file"},
+      rs.recognize_path("/user/download/file"))
 
-    def test_time_recognition
-      # We create many routes to make situation more realistic
-      @rs = ::ActionController::Routing::RouteSet.new
-      @rs.draw { |map|
-        map.frontpage '', :controller => 'search', :action => 'new'
-        map.resources :videos do |video|
-          video.resources :comments
-          video.resource  :file,      :controller => 'video_file'
-          video.resource  :share,     :controller => 'video_shares'
-          video.resource  :abuse,     :controller => 'video_abuses'
-        end
-        map.resources :abuses, :controller => 'video_abuses'
-        map.resources :video_uploads
-        map.resources :video_visits
+    # Now, let's try a file with an extension, really a dot (.)
+    assert_equal '/user/download/file.jpg',
+      rs.generate(
+        :controller => "user", :action => "download", :file => "file.jpg")
+    assert_equal(
+      {:controller => "user", :action => "download", :file => "file.jpg"},
+      rs.recognize_path("/user/download/file.jpg"))
+  end
 
-        map.resources :users do |user|
-          user.resource  :settings
-          user.resources :videos
-        end
-        map.resources :channels do |channel|
-          channel.resources :videos, :controller => 'channel_videos'
-        end
-        map.resource  :session
-        map.resource  :lost_password
-        map.search    'search', :controller => 'search'
-        map.resources :pages
-        map.connect ':controller/:action/:id'
-      }
-      n = 1000
-      if RunTimeTests
-        GC.start
-        rectime = Benchmark.realtime do
-          n.times do
-            rs.recognize_path("/videos/1234567", {:method => :get})
-            rs.recognize_path("/videos/1234567/abuse", {:method => :get})
-            rs.recognize_path("/users/1234567/settings", {:method => :get})
-            rs.recognize_path("/channels/1234567", {:method => :get})
-            rs.recognize_path("/session/new", {:method => :get})
-            rs.recognize_path("/admin/user/show/10", {:method => :get})
-          end
-        end
-        puts "\n\nRecognition (#{rs.routes.size} routes):"
-        per_url = rectime / (n * 6)
-        puts "#{per_url * 1000} ms/url"
-        puts "#{1 / per_url} url/s\n\n"
-      end
-    end
+  def test_basic_named_route
+    rs.add_named_route :home, '', :controller => 'content', :action => 'list'
+    x = setup_for_named_route
+    assert_equal("http://test.host/",
+                 x.send(:home_url))
+  end
 
-    def test_time_generation
-      n = 5000
-      if RunTimeTests
-        GC.start
-        pairs = [
-          [{:controller => 'content', :action => 'index'}, {:controller => 'content', :action => 'show'}],
-          [{:controller => 'content'}, {:controller => 'content', :action => 'index'}],
-          [{:controller => 'content', :action => 'list'}, {:controller => 'content', :action => 'index'}],
-          [{:controller => 'content', :action => 'show', :id => '10'}, {:controller => 'content', :action => 'list'}],
-          [{:controller => 'admin/user', :action => 'index'}, {:controller => 'admin/user', :action => 'show'}],
-          [{:controller => 'admin/user'}, {:controller => 'admin/user', :action => 'index'}],
-          [{:controller => 'admin/user', :action => 'list'}, {:controller => 'admin/user', :action => 'index'}],
-          [{:controller => 'admin/user', :action => 'show', :id => '10'}, {:controller => 'admin/user', :action => 'list'}],
-        ]
-        p = nil
-        gentime = Benchmark.realtime do
-          n.times do
-          pairs.each {|(a, b)| rs.generate(a, b)}
-          end
-        end
+  def test_basic_named_route_with_relative_url_root
+    rs.add_named_route :home, '', :controller => 'content', :action => 'list'
+    x = setup_for_named_route
+    ActionController::Base.relative_url_root = "/foo"
+    assert_equal("http://test.host/foo/",
+                 x.send(:home_url))
+    assert_equal "/foo/", x.send(:home_path)
+    ActionController::Base.relative_url_root = nil
+  end
 
-        puts "\n\nGeneration (RouteSet): (#{(n * 8)} urls)"
-        per_url = gentime / (n * 8)
-        puts "#{per_url * 1000} ms/url"
-        puts "#{1 / per_url} url/s\n\n"
-      end
-    end
+  def test_named_route_with_option
+    rs.add_named_route :page, 'page/:title', :controller => 'content', :action => 'show_page'
+    x = setup_for_named_route
+    assert_equal("http://test.host/page/new%20stuff",
+                 x.send(:page_url, :title => 'new stuff'))
+  end
 
-    def test_route_with_colon_first
-      rs.draw do |map|
-        map.connect '/:controller/:action/:id', :action => 'index', :id => nil
-        map.connect ':url', :controller => 'tiny_url', :action => 'translate'
-      end
-    end
+  def test_named_route_with_default
+    rs.add_named_route :page, 'page/:title', :controller => 'content', :action => 'show_page', :title => 'AboutPage'
+    x = setup_for_named_route
+    assert_equal("http://test.host/page/AboutRails",
+                 x.send(:page_url, :title => "AboutRails"))
 
-    def test_route_with_regexp_for_controller
-      rs.draw do |map|
-        map.connect ':controller/:admintoken/:action/:id', :controller => /admin\/.+/
-        map.connect ':controller/:action/:id'
-      end
-      assert_equal({:controller => "admin/user", :admintoken => "foo", :action => "index"},
-          rs.recognize_path("/admin/user/foo"))
-      assert_equal({:controller => "content", :action => "foo"}, rs.recognize_path("/content/foo"))
-      assert_equal '/admin/user/foo', rs.generate(:controller => "admin/user", :admintoken => "foo", :action => "index")
-      assert_equal '/content/foo', rs.generate(:controller => "content", :action => "foo")
-    end
+  end
 
-    def test_route_with_regexp_and_dot
-      rs.draw do |map|
-        map.connect ':controller/:action/:file',
-                          :controller => /admin|user/,
-                          :action => /upload|download/,
-                          :defaults => {:file => nil},
-                          :requirements => {:file => %r{[^/]+(\.[^/]+)?}}
-      end
-      # Without a file extension
-      assert_equal '/user/download/file',
-        rs.generate(:controller => "user", :action => "download", :file => "file")
-      assert_equal(
-        {:controller => "user", :action => "download", :file => "file"},
-        rs.recognize_path("/user/download/file"))
+  def test_named_route_with_name_prefix
+    rs.add_named_route :page, 'page', :controller => 'content', :action => 'show_page', :name_prefix => 'my_'
+    x = setup_for_named_route
+    assert_equal("http://test.host/page",
+                 x.send(:my_page_url))
+  end
 
-      # Now, let's try a file with an extension, really a dot (.)
-      assert_equal '/user/download/file.jpg',
-        rs.generate(
-          :controller => "user", :action => "download", :file => "file.jpg")
-      assert_equal(
-        {:controller => "user", :action => "download", :file => "file.jpg"},
-        rs.recognize_path("/user/download/file.jpg"))
-    end
+  def test_named_route_with_path_prefix
+    rs.add_named_route :page, 'page', :controller => 'content', :action => 'show_page', :path_prefix => 'my'
+    x = setup_for_named_route
+    assert_equal("http://test.host/my/page",
+                 x.send(:page_url))
+  end
 
-    def test_basic_named_route
-      rs.add_named_route :home, '', :controller => 'content', :action => 'list'
-      x = setup_for_named_route
-      assert_equal("http://test.host/",
-                   x.send(:home_url))
-    end
+  def test_named_route_with_blank_path_prefix
+    rs.add_named_route :page, 'page', :controller => 'content', :action => 'show_page', :path_prefix => ''
+    x = setup_for_named_route
+    assert_equal("http://test.host/page",
+                 x.send(:page_url))
+  end
 
-    def test_basic_named_route_with_relative_url_root
-      rs.add_named_route :home, '', :controller => 'content', :action => 'list'
-      x = setup_for_named_route
-      ActionController::Base.relative_url_root = "/foo"
-      assert_equal("http://test.host/foo/",
-                   x.send(:home_url))
-      assert_equal "/foo/", x.send(:home_path)
-      ActionController::Base.relative_url_root = nil
-    end
+  def test_named_route_with_nested_controller
+    rs.add_named_route :users, 'admin/user', :controller => 'admin/user', :action => 'index'
+    x = setup_for_named_route
+    assert_equal("http://test.host/admin/user",
+                 x.send(:users_url))
+  end
 
-    def test_named_route_with_option
-      rs.add_named_route :page, 'page/:title', :controller => 'content', :action => 'show_page'
-      x = setup_for_named_route
-      assert_equal("http://test.host/page/new%20stuff",
-                   x.send(:page_url, :title => 'new stuff'))
-    end
+  def test_optimised_named_route_call_never_uses_url_for
+    rs.add_named_route :users, 'admin/user', :controller => '/admin/user', :action => 'index'
+    rs.add_named_route :user, 'admin/user/:id', :controller=>'/admin/user', :action=>'show'
+    x = setup_for_named_route
+    x.expects(:url_for).never
+    x.send(:users_url)
+    x.send(:users_path)
+    x.send(:user_url, 2, :foo=>"bar")
+    x.send(:user_path, 3, :bar=>"foo")
+  end
 
-    def test_named_route_with_default
-      rs.add_named_route :page, 'page/:title', :controller => 'content', :action => 'show_page', :title => 'AboutPage'
-      x = setup_for_named_route
-      assert_equal("http://test.host/page/AboutRails",
-                   x.send(:page_url, :title => "AboutRails"))
+  def test_optimised_named_route_with_host
+    rs.add_named_route :pages, 'pages', :controller => 'content', :action => 'show_page', :host => 'foo.com'
+    x = setup_for_named_route
+    x.expects(:url_for).with(:host => 'foo.com', :only_path => false, :controller => 'content', :action => 'show_page', :use_route => :pages).once
+    x.send(:pages_url)
+  end
 
-    end
+  def setup_for_named_route
+    klass = Class.new(MockController)
+    rs.install_helpers(klass)
+    klass.new(rs)
+  end
 
-    def test_named_route_with_name_prefix
-      rs.add_named_route :page, 'page', :controller => 'content', :action => 'show_page', :name_prefix => 'my_'
-      x = setup_for_named_route
-      assert_equal("http://test.host/page",
-                   x.send(:my_page_url))
+  def test_named_route_without_hash
+    rs.draw do |map|
+      map.normal ':controller/:action/:id'
     end
+  end
 
-    def test_named_route_with_path_prefix
-      rs.add_named_route :page, 'page', :controller => 'content', :action => 'show_page', :path_prefix => 'my'
-      x = setup_for_named_route
-      assert_equal("http://test.host/my/page",
-                   x.send(:page_url))
+  def test_named_route_root
+    rs.draw do |map|
+      map.root :controller => "hello"
     end
+    x = setup_for_named_route
+    assert_equal("http://test.host/", x.send(:root_url))
+    assert_equal("/", x.send(:root_path))
+  end
 
-    def test_named_route_with_nested_controller
-      rs.add_named_route :users, 'admin/user', :controller => 'admin/user', :action => 'index'
-      x = setup_for_named_route
-      assert_equal("http://test.host/admin/user",
-                   x.send(:users_url))
+  def test_named_route_with_regexps
+    rs.draw do |map|
+      map.article 'page/:year/:month/:day/:title', :controller => 'page', :action => 'show',
+        :year => /\d+/, :month => /\d+/, :day => /\d+/
+      map.connect ':controller/:action/:id'
     end
+    x = setup_for_named_route
+    # assert_equal(
+    #   {:controller => 'page', :action => 'show', :title => 'hi', :use_route => :article, :only_path => false},
+    #   x.send(:article_url, :title => 'hi')
+    # )
+    assert_equal(
+      "http://test.host/page/2005/6/10/hi",
+      x.send(:article_url, :title => 'hi', :day => 10, :year => 2005, :month => 6)
+    )
+  end
 
-    def test_optimised_named_route_call_never_uses_url_for
-      rs.add_named_route :users, 'admin/user', :controller => '/admin/user', :action => 'index'
-      rs.add_named_route :user, 'admin/user/:id', :controller=>'/admin/user', :action=>'show'
-      x = setup_for_named_route
-      x.expects(:url_for).never
-      x.send(:users_url)
-      x.send(:users_path)
-      x.send(:user_url, 2, :foo=>"bar")
-      x.send(:user_path, 3, :bar=>"foo")
-    end
+  def test_changing_controller
+    @rs.draw {|m| m.connect ':controller/:action/:id' }
 
-    def test_optimised_named_route_with_host
-      rs.add_named_route :pages, 'pages', :controller => 'content', :action => 'show_page', :host => 'foo.com'
-      x = setup_for_named_route
-      x.expects(:url_for).with(:host => 'foo.com', :only_path => false, :controller => 'content', :action => 'show_page', :use_route => :pages).once
-      x.send(:pages_url)
-    end
+    assert_equal '/admin/stuff/show/10', rs.generate(
+      {:controller => 'stuff', :action => 'show', :id => 10},
+      {:controller => 'admin/user', :action => 'index'}
+    )
+  end
 
-    def setup_for_named_route
-      klass = Class.new(MockController)
-      rs.install_helpers(klass)
-      klass.new(rs)
+  def test_paths_escaped
+    rs.draw do |map|
+      map.path 'file/*path', :controller => 'content', :action => 'show_file'
+      map.connect ':controller/:action/:id'
     end
 
-    def test_named_route_without_hash
-      rs.draw do |map|
-        map.normal ':controller/:action/:id'
-      end
-    end
+    # No + to space in URI escaping, only for query params.
+    results = rs.recognize_path "/file/hello+world/how+are+you%3F"
+    assert results, "Recognition should have succeeded"
+    assert_equal ['hello+world', 'how+are+you?'], results[:path]
 
-    def test_named_route_root
-      rs.draw do |map|
-        map.root :controller => "hello"
-      end
-      x = setup_for_named_route
-      assert_equal("http://test.host/", x.send(:root_url))
-      assert_equal("/", x.send(:root_path))
-    end
+    # Use %20 for space instead.
+    results = rs.recognize_path "/file/hello%20world/how%20are%20you%3F"
+    assert results, "Recognition should have succeeded"
+    assert_equal ['hello world', 'how are you?'], results[:path]
 
-    def test_named_route_with_regexps
-      rs.draw do |map|
-        map.article 'page/:year/:month/:day/:title', :controller => 'page', :action => 'show',
-          :year => /\d+/, :month => /\d+/, :day => /\d+/
-        map.connect ':controller/:action/:id'
-      end
-      x = setup_for_named_route
-      # assert_equal(
-      #   {:controller => 'page', :action => 'show', :title => 'hi', :use_route => :article, :only_path => false},
-      #   x.send(:article_url, :title => 'hi')
-      # )
-      assert_equal(
-        "http://test.host/page/2005/6/10/hi",
-        x.send(:article_url, :title => 'hi', :day => 10, :year => 2005, :month => 6)
-      )
-    end
+    results = rs.recognize_path "/file"
+    assert results, "Recognition should have succeeded"
+    assert_equal [], results[:path]
+  end
 
-    def test_changing_controller
-      @rs.draw {|m| m.connect ':controller/:action/:id' }
+  def test_paths_slashes_unescaped_with_ordered_parameters
+    rs.add_named_route :path, '/file/*path', :controller => 'content'
 
-      assert_equal '/admin/stuff/show/10', rs.generate(
-        {:controller => 'stuff', :action => 'show', :id => 10},
-        {:controller => 'admin/user', :action => 'index'}
-      )
+    # No / to %2F in URI, only for query params.
+    x = setup_for_named_route
+    assert_equal("/file/hello/world", x.send(:path_path, 'hello/world'))
+  end
+
+  def test_non_controllers_cannot_be_matched
+    rs.draw do |map|
+      map.connect ':controller/:action/:id'
     end
+    assert_raise(ActionController::RoutingError) { rs.recognize_path("/not_a/show/10") }
+  end
 
-    def test_paths_escaped
+  def test_paths_do_not_accept_defaults
+    assert_raise(ActionController::RoutingError) do
       rs.draw do |map|
-        map.path 'file/*path', :controller => 'content', :action => 'show_file'
+        map.path 'file/*path', :controller => 'content', :action => 'show_file', :path => %w(fake default)
         map.connect ':controller/:action/:id'
       end
-
-      # No + to space in URI escaping, only for query params.
-      results = rs.recognize_path "/file/hello+world/how+are+you%3F"
-      assert results, "Recognition should have succeeded"
-      assert_equal ['hello+world', 'how+are+you?'], results[:path]
-
-      # Use %20 for space instead.
-      results = rs.recognize_path "/file/hello%20world/how%20are%20you%3F"
-      assert results, "Recognition should have succeeded"
-      assert_equal ['hello world', 'how are you?'], results[:path]
-
-      results = rs.recognize_path "/file"
-      assert results, "Recognition should have succeeded"
-      assert_equal [], results[:path]
     end
 
-    def test_paths_slashes_unescaped_with_ordered_parameters
-      rs.add_named_route :path, '/file/*path', :controller => 'content'
-
-      # No / to %2F in URI, only for query params.
-      x = setup_for_named_route
-      assert_equal("/file/hello/world", x.send(:path_path, 'hello/world'))
+    rs.draw do |map|
+      map.path 'file/*path', :controller => 'content', :action => 'show_file', :path => []
+      map.connect ':controller/:action/:id'
     end
+  end
 
-    def test_non_controllers_cannot_be_matched
-      rs.draw do |map|
-        map.connect ':controller/:action/:id'
-      end
-      assert_raises(ActionController::RoutingError) { rs.recognize_path("/not_a/show/10") }
+  def test_should_list_options_diff_when_routing_requirements_dont_match
+    rs.draw do |map|
+      map.post 'post/:id', :controller=> 'post', :action=> 'show', :requirements => {:id => /\d+/}
     end
+    exception = assert_raise(ActionController::RoutingError) { rs.generate(:controller => 'post', :action => 'show', :bad_param => "foo", :use_route => "post") }
+    assert_match /^post_url failed to generate/, exception.message
+    from_match = exception.message.match(/from \{[^\}]+\}/).to_s
+    assert_match /:bad_param=>"foo"/,   from_match
+    assert_match /:action=>"show"/,     from_match
+    assert_match /:controller=>"post"/, from_match
 
-    def test_paths_do_not_accept_defaults
-      assert_raises(ActionController::RoutingError) do
-        rs.draw do |map|
-          map.path 'file/*path', :controller => 'content', :action => 'show_file', :path => %w(fake default)
-          map.connect ':controller/:action/:id'
-        end
-      end
+    expected_match = exception.message.match(/expected: \{[^\}]+\}/).to_s
+    assert_no_match /:bad_param=>"foo"/,   expected_match
+    assert_match    /:action=>"show"/,     expected_match
+    assert_match    /:controller=>"post"/, expected_match
 
-      rs.draw do |map|
-        map.path 'file/*path', :controller => 'content', :action => 'show_file', :path => []
-        map.connect ':controller/:action/:id'
-      end
+    diff_match = exception.message.match(/diff: \{[^\}]+\}/).to_s
+    assert_match    /:bad_param=>"foo"/,   diff_match
+    assert_no_match /:action=>"show"/,     diff_match
+    assert_no_match /:controller=>"post"/, diff_match
+  end
+
+  # this specifies the case where your formerly would get a very confusing error message with an empty diff
+  def test_should_have_better_error_message_when_options_diff_is_empty
+    rs.draw do |map|
+      map.content '/content/:query', :controller => 'content', :action => 'show'
     end
 
-    def test_should_list_options_diff_when_routing_requirements_dont_match
-      rs.draw do |map|
-        map.post 'post/:id', :controller=> 'post', :action=> 'show', :requirements => {:id => /\d+/}
-      end
-      exception = assert_raise(ActionController::RoutingError) { rs.generate(:controller => 'post', :action => 'show', :bad_param => "foo", :use_route => "post") }
-      assert_match /^post_url failed to generate/, exception.message
-      from_match = exception.message.match(/from \{[^\}]+\}/).to_s
-      assert_match /:bad_param=>"foo"/,   from_match
-      assert_match /:action=>"show"/,     from_match
-      assert_match /:controller=>"post"/, from_match
-
-      expected_match = exception.message.match(/expected: \{[^\}]+\}/).to_s
-      assert_no_match /:bad_param=>"foo"/,   expected_match
-      assert_match    /:action=>"show"/,     expected_match
-      assert_match    /:controller=>"post"/, expected_match
-
-      diff_match = exception.message.match(/diff: \{[^\}]+\}/).to_s
-      assert_match    /:bad_param=>"foo"/,   diff_match
-      assert_no_match /:action=>"show"/,     diff_match
-      assert_no_match /:controller=>"post"/, diff_match
-    end
-
-    # this specifies the case where your formerly would get a very confusing error message with an empty diff
-    def test_should_have_better_error_message_when_options_diff_is_empty
-      rs.draw do |map|
-        map.content '/content/:query', :controller => 'content', :action => 'show'
-      end
+    exception = assert_raise(ActionController::RoutingError) { rs.generate(:controller => 'content', :action => 'show', :use_route => "content") }
+    assert_match %r[:action=>"show"], exception.message
+    assert_match %r[:controller=>"content"], exception.message
+    assert_match %r[you may have ambiguous routes, or you may need to supply additional parameters for this route], exception.message
+    assert_match %r[content_url has the following required parameters: \["content", :query\] - are they all satisfied?], exception.message
+  end
 
-      exception = assert_raise(ActionController::RoutingError) { rs.generate(:controller => 'content', :action => 'show', :use_route => "content") }
-      assert_match %r[:action=>"show"], exception.message
-      assert_match %r[:controller=>"content"], exception.message
-      assert_match %r[you may have ambiguous routes, or you may need to supply additional parameters for this route], exception.message
-      assert_match %r[content_url has the following required parameters: \["content", :query\] - are they all satisfied?], exception.message
+  def test_dynamic_path_allowed
+    rs.draw do |map|
+      map.connect '*path', :controller => 'content', :action => 'show_file'
     end
 
-    def test_dynamic_path_allowed
-      rs.draw do |map|
-        map.connect '*path', :controller => 'content', :action => 'show_file'
-      end
+    assert_equal '/pages/boo', rs.generate(:controller => 'content', :action => 'show_file', :path => %w(pages boo))
+  end
 
-      assert_equal '/pages/boo', rs.generate(:controller => 'content', :action => 'show_file', :path => %w(pages boo))
+  def test_dynamic_recall_paths_allowed
+    rs.draw do |map|
+      map.connect '*path', :controller => 'content', :action => 'show_file'
     end
 
-    def test_dynamic_recall_paths_allowed
-      rs.draw do |map|
-        map.connect '*path', :controller => 'content', :action => 'show_file'
-      end
+    recall_path = ActionController::Routing::PathSegment::Result.new(%w(pages boo))
+    assert_equal '/pages/boo', rs.generate({}, :controller => 'content', :action => 'show_file', :path => recall_path)
+  end
 
-      recall_path = ActionController::Routing::PathSegment::Result.new(%w(pages boo))
-      assert_equal '/pages/boo', rs.generate({}, :controller => 'content', :action => 'show_file', :path => recall_path)
+  def test_backwards
+    rs.draw do |map|
+      map.connect 'page/:id/:action', :controller => 'pages', :action => 'show'
+      map.connect ':controller/:action/:id'
     end
 
-    def test_backwards
-      rs.draw do |map|
-        map.connect 'page/:id/:action', :controller => 'pages', :action => 'show'
-        map.connect ':controller/:action/:id'
-      end
+    assert_equal '/page/20', rs.generate({:id => 20}, {:controller => 'pages', :action => 'show'})
+    assert_equal '/page/20', rs.generate(:controller => 'pages', :id => 20, :action => 'show')
+    assert_equal '/pages/boo', rs.generate(:controller => 'pages', :action => 'boo')
+  end
 
-      assert_equal '/page/20', rs.generate({:id => 20}, {:controller => 'pages', :action => 'show'})
-      assert_equal '/page/20', rs.generate(:controller => 'pages', :id => 20, :action => 'show')
-      assert_equal '/pages/boo', rs.generate(:controller => 'pages', :action => 'boo')
+  def test_route_with_fixnum_default
+    rs.draw do |map|
+      map.connect 'page/:id', :controller => 'content', :action => 'show_page', :id => 1
+      map.connect ':controller/:action/:id'
     end
 
-    def test_route_with_fixnum_default
-      rs.draw do |map|
-        map.connect 'page/:id', :controller => 'content', :action => 'show_page', :id => 1
-        map.connect ':controller/:action/:id'
-      end
+    assert_equal '/page', rs.generate(:controller => 'content', :action => 'show_page')
+    assert_equal '/page', rs.generate(:controller => 'content', :action => 'show_page', :id => 1)
+    assert_equal '/page', rs.generate(:controller => 'content', :action => 'show_page', :id => '1')
+    assert_equal '/page/10', rs.generate(:controller => 'content', :action => 'show_page', :id => 10)
 
-      assert_equal '/page', rs.generate(:controller => 'content', :action => 'show_page')
-      assert_equal '/page', rs.generate(:controller => 'content', :action => 'show_page', :id => 1)
-      assert_equal '/page', rs.generate(:controller => 'content', :action => 'show_page', :id => '1')
-      assert_equal '/page/10', rs.generate(:controller => 'content', :action => 'show_page', :id => 10)
+    assert_equal({:controller => "content", :action => 'show_page', :id => '1'}, rs.recognize_path("/page"))
+    assert_equal({:controller => "content", :action => 'show_page', :id => '1'}, rs.recognize_path("/page/1"))
+    assert_equal({:controller => "content", :action => 'show_page', :id => '10'}, rs.recognize_path("/page/10"))
+  end
 
-      assert_equal({:controller => "content", :action => 'show_page', :id => '1'}, rs.recognize_path("/page"))
-      assert_equal({:controller => "content", :action => 'show_page', :id => '1'}, rs.recognize_path("/page/1"))
-      assert_equal({:controller => "content", :action => 'show_page', :id => '10'}, rs.recognize_path("/page/10"))
+  # For newer revision
+  def test_route_with_text_default
+    rs.draw do |map|
+      map.connect 'page/:id', :controller => 'content', :action => 'show_page', :id => 1
+      map.connect ':controller/:action/:id'
     end
 
-    # For newer revision
-    def test_route_with_text_default
-      rs.draw do |map|
-        map.connect 'page/:id', :controller => 'content', :action => 'show_page', :id => 1
-        map.connect ':controller/:action/:id'
-      end
+    assert_equal '/page/foo', rs.generate(:controller => 'content', :action => 'show_page', :id => 'foo')
+    assert_equal({:controller => "content", :action => 'show_page', :id => 'foo'}, rs.recognize_path("/page/foo"))
 
-      assert_equal '/page/foo', rs.generate(:controller => 'content', :action => 'show_page', :id => 'foo')
-      assert_equal({:controller => "content", :action => 'show_page', :id => 'foo'}, rs.recognize_path("/page/foo"))
+    token = "\321\202\320\265\320\272\321\201\321\202" # 'text' in russian
+    token.force_encoding("UTF-8") if token.respond_to?(:force_encoding)
+    escaped_token = CGI::escape(token)
 
-      token = "\321\202\320\265\320\272\321\201\321\202" # 'text' in russian
-      escaped_token = CGI::escape(token)
+    assert_equal '/page/' + escaped_token, rs.generate(:controller => 'content', :action => 'show_page', :id => token)
+    assert_equal({:controller => "content", :action => 'show_page', :id => token}, rs.recognize_path("/page/#{escaped_token}"))
+  end
 
-      assert_equal '/page/' + escaped_token, rs.generate(:controller => 'content', :action => 'show_page', :id => token)
-      assert_equal({:controller => "content", :action => 'show_page', :id => token}, rs.recognize_path("/page/#{escaped_token}"))
-    end
+  def test_action_expiry
+    @rs.draw {|m| m.connect ':controller/:action/:id' }
+    assert_equal '/content', rs.generate({:controller => 'content'}, {:controller => 'content', :action => 'show'})
+  end
 
-    def test_action_expiry
-      @rs.draw {|m| m.connect ':controller/:action/:id' }
-      assert_equal '/content', rs.generate({:controller => 'content'}, {:controller => 'content', :action => 'show'})
-    end
+  def test_recognition_with_uppercase_controller_name
+    @rs.draw {|m| m.connect ':controller/:action/:id' }
+    assert_equal({:controller => "content", :action => 'index'}, rs.recognize_path("/Content"))
+    assert_equal({:controller => "content", :action => 'list'}, rs.recognize_path("/ConTent/list"))
+    assert_equal({:controller => "content", :action => 'show', :id => '10'}, rs.recognize_path("/CONTENT/show/10"))
 
-    def test_recognition_with_uppercase_controller_name
-      @rs.draw {|m| m.connect ':controller/:action/:id' }
-      assert_equal({:controller => "content", :action => 'index'}, rs.recognize_path("/Content"))
-      assert_equal({:controller => "content", :action => 'list'}, rs.recognize_path("/ConTent/list"))
-      assert_equal({:controller => "content", :action => 'show', :id => '10'}, rs.recognize_path("/CONTENT/show/10"))
+    # these used to work, before the routes rewrite, but support for this was pulled in the new version...
+    #assert_equal({'controller' => "admin/news_feed", 'action' => 'index'}, rs.recognize_path("Admin/NewsFeed"))
+    #assert_equal({'controller' => "admin/news_feed", 'action' => 'index'}, rs.recognize_path("Admin/News_Feed"))
+  end
 
-      # these used to work, before the routes rewrite, but support for this was pulled in the new version...
-      #assert_equal({'controller' => "admin/news_feed", 'action' => 'index'}, rs.recognize_path("Admin/NewsFeed"))
-      #assert_equal({'controller' => "admin/news_feed", 'action' => 'index'}, rs.recognize_path("Admin/News_Feed"))
+  def test_requirement_should_prevent_optional_id
+    rs.draw do |map|
+      map.post 'post/:id', :controller=> 'post', :action=> 'show', :requirements => {:id => /\d+/}
     end
 
-    def test_requirement_should_prevent_optional_id
-      rs.draw do |map|
-        map.post 'post/:id', :controller=> 'post', :action=> 'show', :requirements => {:id => /\d+/}
-      end
+    assert_equal '/post/10', rs.generate(:controller => 'post', :action => 'show', :id => 10)
 
-      assert_equal '/post/10', rs.generate(:controller => 'post', :action => 'show', :id => 10)
+    assert_raise ActionController::RoutingError do
+      rs.generate(:controller => 'post', :action => 'show')
+    end
+  end
 
-      assert_raises ActionController::RoutingError do
-        rs.generate(:controller => 'post', :action => 'show')
-      end
+  def test_both_requirement_and_optional
+    rs.draw do |map|
+      map.blog('test/:year', :controller => 'post', :action => 'show',
+        :defaults => { :year => nil },
+        :requirements => { :year => /\d{4}/ }
+      )
+      map.connect ':controller/:action/:id'
     end
 
-    def test_both_requirement_and_optional
-      rs.draw do |map|
-        map.blog('test/:year', :controller => 'post', :action => 'show',
-          :defaults => { :year => nil },
-          :requirements => { :year => /\d{4}/ }
-        )
-        map.connect ':controller/:action/:id'
-      end
+    assert_equal '/test', rs.generate(:controller => 'post', :action => 'show')
+    assert_equal '/test', rs.generate(:controller => 'post', :action => 'show', :year => nil)
 
-      assert_equal '/test', rs.generate(:controller => 'post', :action => 'show')
-      assert_equal '/test', rs.generate(:controller => 'post', :action => 'show', :year => nil)
+    x = setup_for_named_route
+    assert_equal("http://test.host/test",
+                 x.send(:blog_url))
+  end
 
-      x = setup_for_named_route
-      assert_equal("http://test.host/test",
-                   x.send(:blog_url))
+  def test_set_to_nil_forgets
+    rs.draw do |map|
+      map.connect 'pages/:year/:month/:day', :controller => 'content', :action => 'list_pages', :month => nil, :day => nil
+      map.connect ':controller/:action/:id'
     end
 
-    def test_set_to_nil_forgets
-      rs.draw do |map|
-        map.connect 'pages/:year/:month/:day', :controller => 'content', :action => 'list_pages', :month => nil, :day => nil
-        map.connect ':controller/:action/:id'
-      end
+    assert_equal '/pages/2005',
+      rs.generate(:controller => 'content', :action => 'list_pages', :year => 2005)
+    assert_equal '/pages/2005/6',
+      rs.generate(:controller => 'content', :action => 'list_pages', :year => 2005, :month => 6)
+    assert_equal '/pages/2005/6/12',
+      rs.generate(:controller => 'content', :action => 'list_pages', :year => 2005, :month => 6, :day => 12)
 
-      assert_equal '/pages/2005',
-        rs.generate(:controller => 'content', :action => 'list_pages', :year => 2005)
-      assert_equal '/pages/2005/6',
-        rs.generate(:controller => 'content', :action => 'list_pages', :year => 2005, :month => 6)
-      assert_equal '/pages/2005/6/12',
-        rs.generate(:controller => 'content', :action => 'list_pages', :year => 2005, :month => 6, :day => 12)
+    assert_equal '/pages/2005/6/4',
+      rs.generate({:day => 4}, {:controller => 'content', :action => 'list_pages', :year => '2005', :month => '6', :day => '12'})
 
-      assert_equal '/pages/2005/6/4',
-        rs.generate({:day => 4}, {:controller => 'content', :action => 'list_pages', :year => '2005', :month => '6', :day => '12'})
+    assert_equal '/pages/2005/6',
+      rs.generate({:day => nil}, {:controller => 'content', :action => 'list_pages', :year => '2005', :month => '6', :day => '12'})
 
-      assert_equal '/pages/2005/6',
-        rs.generate({:day => nil}, {:controller => 'content', :action => 'list_pages', :year => '2005', :month => '6', :day => '12'})
+    assert_equal '/pages/2005',
+      rs.generate({:day => nil, :month => nil}, {:controller => 'content', :action => 'list_pages', :year => '2005', :month => '6', :day => '12'})
+  end
 
-      assert_equal '/pages/2005',
-        rs.generate({:day => nil, :month => nil}, {:controller => 'content', :action => 'list_pages', :year => '2005', :month => '6', :day => '12'})
+  def test_url_with_no_action_specified
+    rs.draw do |map|
+      map.connect '', :controller => 'content'
+      map.connect ':controller/:action/:id'
     end
 
-    def test_url_with_no_action_specified
-      rs.draw do |map|
-        map.connect '', :controller => 'content'
-        map.connect ':controller/:action/:id'
-      end
+    assert_equal '/', rs.generate(:controller => 'content', :action => 'index')
+    assert_equal '/', rs.generate(:controller => 'content')
+  end
 
-      assert_equal '/', rs.generate(:controller => 'content', :action => 'index')
-      assert_equal '/', rs.generate(:controller => 'content')
+  def test_named_url_with_no_action_specified
+    rs.draw do |map|
+      map.home '', :controller => 'content'
+      map.connect ':controller/:action/:id'
     end
 
-    def test_named_url_with_no_action_specified
+    assert_equal '/', rs.generate(:controller => 'content', :action => 'index')
+    assert_equal '/', rs.generate(:controller => 'content')
+
+    x = setup_for_named_route
+    assert_equal("http://test.host/",
+                 x.send(:home_url))
+  end
+
+  def test_url_generated_when_forgetting_action
+    [{:controller => 'content', :action => 'index'}, {:controller => 'content'}].each do |hash|
       rs.draw do |map|
-        map.home '', :controller => 'content'
+        map.home '', hash
         map.connect ':controller/:action/:id'
       end
-
-      assert_equal '/', rs.generate(:controller => 'content', :action => 'index')
-      assert_equal '/', rs.generate(:controller => 'content')
-
-      x = setup_for_named_route
-      assert_equal("http://test.host/",
-                   x.send(:home_url))
+      assert_equal '/', rs.generate({:action => nil}, {:controller => 'content', :action => 'hello'})
+      assert_equal '/', rs.generate({:controller => 'content'})
+      assert_equal '/content/hi', rs.generate({:controller => 'content', :action => 'hi'})
     end
+  end
 
-    def test_url_generated_when_forgetting_action
-      [{:controller => 'content', :action => 'index'}, {:controller => 'content'}].each do |hash|
-        rs.draw do |map|
-          map.home '', hash
-          map.connect ':controller/:action/:id'
-        end
-        assert_equal '/', rs.generate({:action => nil}, {:controller => 'content', :action => 'hello'})
-        assert_equal '/', rs.generate({:controller => 'content'})
-        assert_equal '/content/hi', rs.generate({:controller => 'content', :action => 'hi'})
-      end
+  def test_named_route_method
+    rs.draw do |map|
+      map.categories 'categories', :controller => 'content', :action => 'categories'
+      map.connect ':controller/:action/:id'
     end
 
-    def test_named_route_method
-      rs.draw do |map|
-        map.categories 'categories', :controller => 'content', :action => 'categories'
-        map.connect ':controller/:action/:id'
-      end
+    assert_equal '/categories', rs.generate(:controller => 'content', :action => 'categories')
+    assert_equal '/content/hi', rs.generate({:controller => 'content', :action => 'hi'})
+  end
 
-      assert_equal '/categories', rs.generate(:controller => 'content', :action => 'categories')
-      assert_equal '/content/hi', rs.generate({:controller => 'content', :action => 'hi'})
-    end
+  def test_named_routes_array
+    test_named_route_method
+    assert_equal [:categories], rs.named_routes.names
+  end
 
-    def test_named_routes_array
-      test_named_route_method
-      assert_equal [:categories], rs.named_routes.names
+  def test_nil_defaults
+    rs.draw do |map|
+      map.connect 'journal',
+        :controller => 'content',
+        :action => 'list_journal',
+        :date => nil, :user_id => nil
+      map.connect ':controller/:action/:id'
     end
 
-    def test_nil_defaults
-      rs.draw do |map|
-        map.connect 'journal',
-          :controller => 'content',
-          :action => 'list_journal',
-          :date => nil, :user_id => nil
-        map.connect ':controller/:action/:id'
-      end
+    assert_equal '/journal', rs.generate(:controller => 'content', :action => 'list_journal', :date => nil, :user_id => nil)
+  end
+
+  def setup_request_method_routes_for(method)
+    @request = ActionController::TestRequest.new
+    @request.env["REQUEST_METHOD"] = method
+    @request.request_uri = "/match"
 
-      assert_equal '/journal', rs.generate(:controller => 'content', :action => 'list_journal', :date => nil, :user_id => nil)
+    rs.draw do |r|
+      r.connect '/match', :controller => 'books', :action => 'get', :conditions => { :method => :get }
+      r.connect '/match', :controller => 'books', :action => 'post', :conditions => { :method => :post }
+      r.connect '/match', :controller => 'books', :action => 'put', :conditions => { :method => :put }
+      r.connect '/match', :controller => 'books', :action => 'delete', :conditions => { :method => :delete }
     end
+  end
+
+  %w(GET POST PUT DELETE).each do |request_method|
+    define_method("test_request_method_recognized_with_#{request_method}") do
+      begin
+        Object.const_set(:BooksController, Class.new(ActionController::Base))
 
-    def setup_request_method_routes_for(method)
-      @request = ActionController::TestRequest.new
-      @request.env["REQUEST_METHOD"] = method
-      @request.request_uri = "/match"
+        setup_request_method_routes_for(request_method)
 
-      rs.draw do |r|
-        r.connect '/match', :controller => 'books', :action => 'get', :conditions => { :method => :get }
-        r.connect '/match', :controller => 'books', :action => 'post', :conditions => { :method => :post }
-        r.connect '/match', :controller => 'books', :action => 'put', :conditions => { :method => :put }
-        r.connect '/match', :controller => 'books', :action => 'delete', :conditions => { :method => :delete }
+        assert_nothing_raised { rs.recognize(@request) }
+        assert_equal request_method.downcase, @request.path_parameters[:action]
+      ensure
+        Object.send(:remove_const, :BooksController) rescue nil
       end
     end
+  end
 
-    %w(GET POST PUT DELETE).each do |request_method|
-      define_method("test_request_method_recognized_with_#{request_method}") do
-        begin
-          Object.const_set(:BooksController, Class.new(ActionController::Base))
+  def test_recognize_array_of_methods
+    Object.const_set(:BooksController, Class.new(ActionController::Base))
+    rs.draw do |r|
+      r.connect '/match', :controller => 'books', :action => 'get_or_post', :conditions => { :method => [:get, :post] }
+      r.connect '/match', :controller => 'books', :action => 'not_get_or_post'
+    end
 
-          setup_request_method_routes_for(request_method)
+    @request = ActionController::TestRequest.new
+    @request.env["REQUEST_METHOD"] = 'POST'
+    @request.request_uri = "/match"
+    assert_nothing_raised { rs.recognize(@request) }
+    assert_equal 'get_or_post', @request.path_parameters[:action]
 
-          assert_nothing_raised { rs.recognize(@request) }
-          assert_equal request_method.downcase, @request.path_parameters[:action]
-        ensure
-          Object.send(:remove_const, :BooksController) rescue nil
-        end
-      end
+    # have to recreate or else the RouteSet uses a cached version:
+    @request = ActionController::TestRequest.new
+    @request.env["REQUEST_METHOD"] = 'PUT'
+    @request.request_uri = "/match"
+    assert_nothing_raised { rs.recognize(@request) }
+    assert_equal 'not_get_or_post', @request.path_parameters[:action]
+  ensure
+    Object.send(:remove_const, :BooksController) rescue nil
+  end
+
+  def test_subpath_recognized
+    Object.const_set(:SubpathBooksController, Class.new(ActionController::Base))
+
+    rs.draw do |r|
+      r.connect '/books/:id/edit', :controller => 'subpath_books', :action => 'edit'
+      r.connect '/items/:id/:action', :controller => 'subpath_books'
+      r.connect '/posts/new/:action', :controller => 'subpath_books'
+      r.connect '/posts/:id', :controller => 'subpath_books', :action => "show"
     end
 
-    def test_recognize_array_of_methods
-      Object.const_set(:BooksController, Class.new(ActionController::Base))
-      rs.draw do |r|
-        r.connect '/match', :controller => 'books', :action => 'get_or_post', :conditions => { :method => [:get, :post] }
-        r.connect '/match', :controller => 'books', :action => 'not_get_or_post'
-      end
+    hash = rs.recognize_path "/books/17/edit"
+    assert_not_nil hash
+    assert_equal %w(subpath_books 17 edit), [hash[:controller], hash[:id], hash[:action]]
 
-      @request = ActionController::TestRequest.new
-      @request.env["REQUEST_METHOD"] = 'POST'
-      @request.request_uri = "/match"
-      assert_nothing_raised { rs.recognize(@request) }
-      assert_equal 'get_or_post', @request.path_parameters[:action]
-
-      # have to recreate or else the RouteSet uses a cached version:
-      @request = ActionController::TestRequest.new
-      @request.env["REQUEST_METHOD"] = 'PUT'
-      @request.request_uri = "/match"
-      assert_nothing_raised { rs.recognize(@request) }
-      assert_equal 'not_get_or_post', @request.path_parameters[:action]
-    ensure
-      Object.send(:remove_const, :BooksController) rescue nil
-    end
-
-    def test_subpath_recognized
-      Object.const_set(:SubpathBooksController, Class.new(ActionController::Base))
-
-      rs.draw do |r|
-        r.connect '/books/:id/edit', :controller => 'subpath_books', :action => 'edit'
-        r.connect '/items/:id/:action', :controller => 'subpath_books'
-        r.connect '/posts/new/:action', :controller => 'subpath_books'
-        r.connect '/posts/:id', :controller => 'subpath_books', :action => "show"
-      end
+    hash = rs.recognize_path "/items/3/complete"
+    assert_not_nil hash
+    assert_equal %w(subpath_books 3 complete), [hash[:controller], hash[:id], hash[:action]]
 
-      hash = rs.recognize_path "/books/17/edit"
-      assert_not_nil hash
-      assert_equal %w(subpath_books 17 edit), [hash[:controller], hash[:id], hash[:action]]
+    hash = rs.recognize_path "/posts/new/preview"
+    assert_not_nil hash
+    assert_equal %w(subpath_books preview), [hash[:controller], hash[:action]]
 
-      hash = rs.recognize_path "/items/3/complete"
-      assert_not_nil hash
-      assert_equal %w(subpath_books 3 complete), [hash[:controller], hash[:id], hash[:action]]
+    hash = rs.recognize_path "/posts/7"
+    assert_not_nil hash
+    assert_equal %w(subpath_books show 7), [hash[:controller], hash[:action], hash[:id]]
+  ensure
+    Object.send(:remove_const, :SubpathBooksController) rescue nil
+  end
 
-      hash = rs.recognize_path "/posts/new/preview"
-      assert_not_nil hash
-      assert_equal %w(subpath_books preview), [hash[:controller], hash[:action]]
+  def test_subpath_generated
+    Object.const_set(:SubpathBooksController, Class.new(ActionController::Base))
 
-      hash = rs.recognize_path "/posts/7"
-      assert_not_nil hash
-      assert_equal %w(subpath_books show 7), [hash[:controller], hash[:action], hash[:id]]
-    ensure
-      Object.send(:remove_const, :SubpathBooksController) rescue nil
+    rs.draw do |r|
+      r.connect '/books/:id/edit', :controller => 'subpath_books', :action => 'edit'
+      r.connect '/items/:id/:action', :controller => 'subpath_books'
+      r.connect '/posts/new/:action', :controller => 'subpath_books'
     end
 
-    def test_subpath_generated
-      Object.const_set(:SubpathBooksController, Class.new(ActionController::Base))
-
-      rs.draw do |r|
-        r.connect '/books/:id/edit', :controller => 'subpath_books', :action => 'edit'
-        r.connect '/items/:id/:action', :controller => 'subpath_books'
-        r.connect '/posts/new/:action', :controller => 'subpath_books'
-      end
+    assert_equal "/books/7/edit", rs.generate(:controller => "subpath_books", :id => 7, :action => "edit")
+    assert_equal "/items/15/complete", rs.generate(:controller => "subpath_books", :id => 15, :action => "complete")
+    assert_equal "/posts/new/preview", rs.generate(:controller => "subpath_books", :action => "preview")
+  ensure
+    Object.send(:remove_const, :SubpathBooksController) rescue nil
+  end
 
-      assert_equal "/books/7/edit", rs.generate(:controller => "subpath_books", :id => 7, :action => "edit")
-      assert_equal "/items/15/complete", rs.generate(:controller => "subpath_books", :id => 15, :action => "complete")
-      assert_equal "/posts/new/preview", rs.generate(:controller => "subpath_books", :action => "preview")
-    ensure
-      Object.send(:remove_const, :SubpathBooksController) rescue nil
+  def test_failed_requirements_raises_exception_with_violated_requirements
+    rs.draw do |r|
+      r.foo_with_requirement 'foos/:id', :controller=>'foos', :requirements=>{:id=>/\d+/}
     end
 
-    def test_failed_requirements_raises_exception_with_violated_requirements
-      rs.draw do |r|
-        r.foo_with_requirement 'foos/:id', :controller=>'foos', :requirements=>{:id=>/\d+/}
-      end
+    x = setup_for_named_route
+    assert_raise(ActionController::RoutingError) do
+      x.send(:foo_with_requirement_url, "I am Against the requirements")
+    end
+  end
 
-      x = setup_for_named_route
-      assert_raises(ActionController::RoutingError) do
-        x.send(:foo_with_requirement_url, "I am Against the requirements")
-      end
+  def test_routes_changed_correctly_after_clear
+    ActionController::Base.optimise_named_routes = true
+    rs = ::ActionController::Routing::RouteSet.new
+    rs.draw do |r|
+      r.connect 'ca', :controller => 'ca', :action => "aa"
+      r.connect 'cb', :controller => 'cb', :action => "ab"
+      r.connect 'cc', :controller => 'cc', :action => "ac"
+      r.connect ':controller/:action/:id'
+      r.connect ':controller/:action/:id.:format'
     end
 
-    def test_routes_changed_correctly_after_clear
-      ActionController::Base.optimise_named_routes = true
-      rs = ::ActionController::Routing::RouteSet.new
-      rs.draw do |r|
-        r.connect 'ca', :controller => 'ca', :action => "aa"
-        r.connect 'cb', :controller => 'cb', :action => "ab"
-        r.connect 'cc', :controller => 'cc', :action => "ac"
-        r.connect ':controller/:action/:id'
-        r.connect ':controller/:action/:id.:format'
-      end
+    hash = rs.recognize_path "/cc"
 
-      hash = rs.recognize_path "/cc"
+    assert_not_nil hash
+    assert_equal %w(cc ac), [hash[:controller], hash[:action]]
 
-      assert_not_nil hash
-      assert_equal %w(cc ac), [hash[:controller], hash[:action]]
+    rs.draw do |r|
+      r.connect 'cb', :controller => 'cb', :action => "ab"
+      r.connect 'cc', :controller => 'cc', :action => "ac"
+      r.connect ':controller/:action/:id'
+      r.connect ':controller/:action/:id.:format'
+    end
 
-      rs.draw do |r|
-        r.connect 'cb', :controller => 'cb', :action => "ab"
-        r.connect 'cc', :controller => 'cc', :action => "ac"
-        r.connect ':controller/:action/:id'
-        r.connect ':controller/:action/:id.:format'
-      end
+    hash = rs.recognize_path "/cc"
 
-      hash = rs.recognize_path "/cc"
+    assert_not_nil hash
+    assert_equal %w(cc ac), [hash[:controller], hash[:action]]
 
-      assert_not_nil hash
-      assert_equal %w(cc ac), [hash[:controller], hash[:action]]
+  end
+end
 
-    end
+class RouteTest < Test::Unit::TestCase
+  def setup
+    @route = ROUTING::Route.new
   end
 
-  class RouteTest < Test::Unit::TestCase
-    def setup
-      @route = ROUTING::Route.new
-    end
+  def slash_segment(is_optional = false)
+    ROUTING::DividerSegment.new('/', :optional => is_optional)
+  end
 
-    def slash_segment(is_optional = false)
-      ROUTING::DividerSegment.new('/', :optional => is_optional)
+  def default_route
+    unless defined?(@default_route)
+      segments = []
+      segments << ROUTING::StaticSegment.new('/', :raw => true)
+      segments << ROUTING::DynamicSegment.new(:controller)
+      segments << slash_segment(:optional)
+      segments << ROUTING::DynamicSegment.new(:action, :default => 'index', :optional => true)
+      segments << slash_segment(:optional)
+      segments << ROUTING::DynamicSegment.new(:id, :optional => true)
+      segments << slash_segment(:optional)
+      @default_route = ROUTING::Route.new(segments).freeze
     end
+    @default_route
+  end
 
-    def default_route
-      unless defined?(@default_route)
-        segments = []
-        segments << ROUTING::StaticSegment.new('/', :raw => true)
-        segments << ROUTING::DynamicSegment.new(:controller)
-        segments << slash_segment(:optional)
-        segments << ROUTING::DynamicSegment.new(:action, :default => 'index', :optional => true)
-        segments << slash_segment(:optional)
-        segments << ROUTING::DynamicSegment.new(:id, :optional => true)
-        segments << slash_segment(:optional)
-        @default_route = ROUTING::Route.new(segments).freeze
-      end
-      @default_route
-    end
+  def test_default_route_recognition
+    expected = {:controller => 'accounts', :action => 'show', :id => '10'}
+    assert_equal expected, default_route.recognize('/accounts/show/10')
+    assert_equal expected, default_route.recognize('/accounts/show/10/')
 
-    def test_default_route_recognition
-      expected = {:controller => 'accounts', :action => 'show', :id => '10'}
-      assert_equal expected, default_route.recognize('/accounts/show/10')
-      assert_equal expected, default_route.recognize('/accounts/show/10/')
+    expected[:id] = 'jamis'
+    assert_equal expected, default_route.recognize('/accounts/show/jamis/')
 
-      expected[:id] = 'jamis'
-      assert_equal expected, default_route.recognize('/accounts/show/jamis/')
+    expected.delete :id
+    assert_equal expected, default_route.recognize('/accounts/show')
+    assert_equal expected, default_route.recognize('/accounts/show/')
 
-      expected.delete :id
-      assert_equal expected, default_route.recognize('/accounts/show')
-      assert_equal expected, default_route.recognize('/accounts/show/')
+    expected[:action] = 'index'
+    assert_equal expected, default_route.recognize('/accounts/')
+    assert_equal expected, default_route.recognize('/accounts')
 
-      expected[:action] = 'index'
-      assert_equal expected, default_route.recognize('/accounts/')
-      assert_equal expected, default_route.recognize('/accounts')
+    assert_equal nil, default_route.recognize('/')
+    assert_equal nil, default_route.recognize('/accounts/how/goood/it/is/to/be/free')
+  end
 
-      assert_equal nil, default_route.recognize('/')
-      assert_equal nil, default_route.recognize('/accounts/how/goood/it/is/to/be/free')
-    end
+  def test_default_route_should_omit_default_action
+    o = {:controller => 'accounts', :action => 'index'}
+    assert_equal '/accounts', default_route.generate(o, o, {})
+  end
 
-    def test_default_route_should_omit_default_action
-      o = {:controller => 'accounts', :action => 'index'}
-      assert_equal '/accounts', default_route.generate(o, o, {})
-    end
+  def test_default_route_should_include_default_action_when_id_present
+    o = {:controller => 'accounts', :action => 'index', :id => '20'}
+    assert_equal '/accounts/index/20', default_route.generate(o, o, {})
+  end
 
-    def test_default_route_should_include_default_action_when_id_present
-      o = {:controller => 'accounts', :action => 'index', :id => '20'}
-      assert_equal '/accounts/index/20', default_route.generate(o, o, {})
-    end
+  def test_default_route_should_work_with_action_but_no_id
+    o = {:controller => 'accounts', :action => 'list_all'}
+    assert_equal '/accounts/list_all', default_route.generate(o, o, {})
+  end
 
-    def test_default_route_should_work_with_action_but_no_id
-      o = {:controller => 'accounts', :action => 'list_all'}
-      assert_equal '/accounts/list_all', default_route.generate(o, o, {})
-    end
+  def test_default_route_should_uri_escape_pluses
+    expected = { :controller => 'accounts', :action => 'show', :id => 'hello world' }
+    assert_equal expected, default_route.recognize('/accounts/show/hello world')
+    assert_equal expected, default_route.recognize('/accounts/show/hello%20world')
+    assert_equal '/accounts/show/hello%20world', default_route.generate(expected, expected, {})
 
-    def test_default_route_should_uri_escape_pluses
-      expected = { :controller => 'accounts', :action => 'show', :id => 'hello world' }
-      assert_equal expected, default_route.recognize('/accounts/show/hello world')
-      assert_equal expected, default_route.recognize('/accounts/show/hello%20world')
-      assert_equal '/accounts/show/hello%20world', default_route.generate(expected, expected, {})
+    expected[:id] = 'hello+world'
+    assert_equal expected, default_route.recognize('/accounts/show/hello+world')
+    assert_equal expected, default_route.recognize('/accounts/show/hello%2Bworld')
+    assert_equal '/accounts/show/hello+world', default_route.generate(expected, expected, {})
+  end
 
-      expected[:id] = 'hello+world'
-      assert_equal expected, default_route.recognize('/accounts/show/hello+world')
-      assert_equal expected, default_route.recognize('/accounts/show/hello%2Bworld')
-      assert_equal '/accounts/show/hello+world', default_route.generate(expected, expected, {})
-    end
+  def test_matches_controller_and_action
+    # requirement_for should only be called for the action and controller _once_
+    @route.expects(:requirement_for).with(:controller).times(1).returns('pages')
+    @route.expects(:requirement_for).with(:action).times(1).returns('show')
 
-    def test_matches_controller_and_action
-      # requirement_for should only be called for the action and controller _once_
-      @route.expects(:requirement_for).with(:controller).times(1).returns('pages')
-      @route.expects(:requirement_for).with(:action).times(1).returns('show')
+    @route.requirements = {:controller => 'pages', :action => 'show'}
+    assert @route.matches_controller_and_action?('pages', 'show')
+    assert !@route.matches_controller_and_action?('not_pages', 'show')
+    assert !@route.matches_controller_and_action?('pages', 'not_show')
+  end
 
-      @route.requirements = {:controller => 'pages', :action => 'show'}
-      assert @route.matches_controller_and_action?('pages', 'show')
-      assert !@route.matches_controller_and_action?('not_pages', 'show')
-      assert !@route.matches_controller_and_action?('pages', 'not_show')
-    end
+  def test_parameter_shell
+    page_url = ROUTING::Route.new
+    page_url.requirements = {:controller => 'pages', :action => 'show', :id => /\d+/}
+    assert_equal({:controller => 'pages', :action => 'show'}, page_url.parameter_shell)
+  end
 
-    def test_parameter_shell
-      page_url = ROUTING::Route.new
-      page_url.requirements = {:controller => 'pages', :action => 'show', :id => /\d+/}
-      assert_equal({:controller => 'pages', :action => 'show'}, page_url.parameter_shell)
-    end
+  def test_defaults
+    route = ROUTING::RouteBuilder.new.build '/users/:id.:format', :controller => "users", :action => "show", :format => "html"
+    assert_equal(
+      { :controller => "users", :action => "show", :format => "html" },
+      route.defaults)
+  end
 
-    def test_defaults
-      route = ROUTING::RouteBuilder.new.build '/users/:id.:format', :controller => "users", :action => "show", :format => "html"
-      assert_equal(
-        { :controller => "users", :action => "show", :format => "html" },
-        route.defaults)
+  def test_builder_complains_without_controller
+    assert_raise(ArgumentError) do
+      ROUTING::RouteBuilder.new.build '/contact', :contoller => "contact", :action => "index"
     end
+  end
 
-    def test_builder_complains_without_controller
-      assert_raises(ArgumentError) do
-        ROUTING::RouteBuilder.new.build '/contact', :contoller => "contact", :action => "index"
-      end
-    end
+  def test_significant_keys_for_default_route
+    keys = default_route.significant_keys.sort_by {|k| k.to_s }
+    assert_equal [:action, :controller, :id], keys
+  end
 
-    def test_significant_keys_for_default_route
-      keys = default_route.significant_keys.sort_by {|k| k.to_s }
-      assert_equal [:action, :controller, :id], keys
-    end
+  def test_significant_keys
+    segments = []
+    segments << ROUTING::StaticSegment.new('/', :raw => true)
+    segments << ROUTING::StaticSegment.new('user')
+    segments << ROUTING::StaticSegment.new('/', :raw => true, :optional => true)
+    segments << ROUTING::DynamicSegment.new(:user)
+    segments << ROUTING::StaticSegment.new('/', :raw => true, :optional => true)
 
-    def test_significant_keys
-      segments = []
-      segments << ROUTING::StaticSegment.new('/', :raw => true)
-      segments << ROUTING::StaticSegment.new('user')
-      segments << ROUTING::StaticSegment.new('/', :raw => true, :optional => true)
-      segments << ROUTING::DynamicSegment.new(:user)
-      segments << ROUTING::StaticSegment.new('/', :raw => true, :optional => true)
+    requirements = {:controller => 'users', :action => 'show'}
 
-      requirements = {:controller => 'users', :action => 'show'}
+    user_url = ROUTING::Route.new(segments, requirements)
+    keys = user_url.significant_keys.sort_by { |k| k.to_s }
+    assert_equal [:action, :controller, :user], keys
+  end
 
-      user_url = ROUTING::Route.new(segments, requirements)
-      keys = user_url.significant_keys.sort_by { |k| k.to_s }
-      assert_equal [:action, :controller, :user], keys
-    end
+  def test_build_empty_query_string
+    assert_equal '', @route.build_query_string({})
+  end
 
-    def test_build_empty_query_string
-      assert_equal '', @route.build_query_string({})
-    end
+  def test_build_query_string_with_nil_value
+    assert_equal '', @route.build_query_string({:x => nil})
+  end
 
-    def test_build_query_string_with_nil_value
-      assert_equal '', @route.build_query_string({:x => nil})
-    end
+  def test_simple_build_query_string
+    assert_equal '?x=1&y=2', order_query_string(@route.build_query_string(:x => '1', :y => '2'))
+  end
 
-    def test_simple_build_query_string
-      assert_equal '?x=1&y=2', order_query_string(@route.build_query_string(:x => '1', :y => '2'))
-    end
+  def test_convert_ints_build_query_string
+    assert_equal '?x=1&y=2', order_query_string(@route.build_query_string(:x => 1, :y => 2))
+  end
 
-    def test_convert_ints_build_query_string
-      assert_equal '?x=1&y=2', order_query_string(@route.build_query_string(:x => 1, :y => 2))
-    end
+  def test_escape_spaces_build_query_string
+    assert_equal '?x=hello+world&y=goodbye+world', order_query_string(@route.build_query_string(:x => 'hello world', :y => 'goodbye world'))
+  end
 
-    def test_escape_spaces_build_query_string
-      assert_equal '?x=hello+world&y=goodbye+world', order_query_string(@route.build_query_string(:x => 'hello world', :y => 'goodbye world'))
-    end
+  def test_expand_array_build_query_string
+    assert_equal '?x%5B%5D=1&x%5B%5D=2', order_query_string(@route.build_query_string(:x => [1, 2]))
+  end
 
-    def test_expand_array_build_query_string
-      assert_equal '?x%5B%5D=1&x%5B%5D=2', order_query_string(@route.build_query_string(:x => [1, 2]))
-    end
+  def test_escape_spaces_build_query_string_selected_keys
+    assert_equal '?x=hello+world', order_query_string(@route.build_query_string({:x => 'hello world', :y => 'goodbye world'}, [:x]))
+  end
 
-    def test_escape_spaces_build_query_string_selected_keys
-      assert_equal '?x=hello+world', order_query_string(@route.build_query_string({:x => 'hello world', :y => 'goodbye world'}, [:x]))
+  private
+    def order_query_string(qs)
+      '?' + qs[1..-1].split('&').sort.join('&')
     end
+end
 
-    private
-      def order_query_string(qs)
-        '?' + qs[1..-1].split('&').sort.join('&')
-      end
+class RouteSetTest < Test::Unit::TestCase
+  def set
+    @set ||= ROUTING::RouteSet.new
   end
 
-  class RouteSetTest < Test::Unit::TestCase
-    def set
-      @set ||= ROUTING::RouteSet.new
-    end
+  def request
+    @request ||= ActionController::TestRequest.new
+  end
 
-    def request
-      @request ||= ActionController::TestRequest.new
-    end
+  def test_generate_extras
+    set.draw { |m| m.connect ':controller/:action/:id' }
+    path, extras = set.generate_extras(:controller => "foo", :action => "bar", :id => 15, :this => "hello", :that => "world")
+    assert_equal "/foo/bar/15", path
+    assert_equal %w(that this), extras.map(&:to_s).sort
+  end
 
-    def test_generate_extras
-      set.draw { |m| m.connect ':controller/:action/:id' }
-      path, extras = set.generate_extras(:controller => "foo", :action => "bar", :id => 15, :this => "hello", :that => "world")
-      assert_equal "/foo/bar/15", path
-      assert_equal %w(that this), extras.map(&:to_s).sort
-    end
+  def test_extra_keys
+    set.draw { |m| m.connect ':controller/:action/:id' }
+    extras = set.extra_keys(:controller => "foo", :action => "bar", :id => 15, :this => "hello", :that => "world")
+    assert_equal %w(that this), extras.map(&:to_s).sort
+  end
 
-    def test_extra_keys
-      set.draw { |m| m.connect ':controller/:action/:id' }
-      extras = set.extra_keys(:controller => "foo", :action => "bar", :id => 15, :this => "hello", :that => "world")
-      assert_equal %w(that this), extras.map(&:to_s).sort
+  def test_generate_extras_not_first
+    set.draw do |map|
+      map.connect ':controller/:action/:id.:format'
+      map.connect ':controller/:action/:id'
     end
+    path, extras = set.generate_extras(:controller => "foo", :action => "bar", :id => 15, :this => "hello", :that => "world")
+    assert_equal "/foo/bar/15", path
+    assert_equal %w(that this), extras.map(&:to_s).sort
+  end
 
-    def test_generate_extras_not_first
-      set.draw do |map|
-        map.connect ':controller/:action/:id.:format'
-        map.connect ':controller/:action/:id'
-      end
-      path, extras = set.generate_extras(:controller => "foo", :action => "bar", :id => 15, :this => "hello", :that => "world")
-      assert_equal "/foo/bar/15", path
-      assert_equal %w(that this), extras.map(&:to_s).sort
+  def test_generate_not_first
+    set.draw do |map|
+      map.connect ':controller/:action/:id.:format'
+      map.connect ':controller/:action/:id'
     end
+    assert_equal "/foo/bar/15?this=hello", set.generate(:controller => "foo", :action => "bar", :id => 15, :this => "hello")
+  end
 
-    def test_generate_not_first
-      set.draw do |map|
-        map.connect ':controller/:action/:id.:format'
-        map.connect ':controller/:action/:id'
-      end
-      assert_equal "/foo/bar/15?this=hello", set.generate(:controller => "foo", :action => "bar", :id => 15, :this => "hello")
+  def test_extra_keys_not_first
+    set.draw do |map|
+      map.connect ':controller/:action/:id.:format'
+      map.connect ':controller/:action/:id'
     end
+    extras = set.extra_keys(:controller => "foo", :action => "bar", :id => 15, :this => "hello", :that => "world")
+    assert_equal %w(that this), extras.map(&:to_s).sort
+  end
 
-    def test_extra_keys_not_first
-      set.draw do |map|
-        map.connect ':controller/:action/:id.:format'
-        map.connect ':controller/:action/:id'
-      end
-      extras = set.extra_keys(:controller => "foo", :action => "bar", :id => 15, :this => "hello", :that => "world")
-      assert_equal %w(that this), extras.map(&:to_s).sort
+  def test_draw
+    assert_equal 0, set.routes.size
+    set.draw do |map|
+      map.connect '/hello/world', :controller => 'a', :action => 'b'
     end
+    assert_equal 1, set.routes.size
+  end
 
-    def test_draw
-      assert_equal 0, set.routes.size
-      set.draw do |map|
-        map.connect '/hello/world', :controller => 'a', :action => 'b'
-      end
-      assert_equal 1, set.routes.size
+  def test_named_draw
+    assert_equal 0, set.routes.size
+    set.draw do |map|
+      map.hello '/hello/world', :controller => 'a', :action => 'b'
     end
+    assert_equal 1, set.routes.size
+    assert_equal set.routes.first, set.named_routes[:hello]
+  end
 
-    def test_named_draw
-      assert_equal 0, set.routes.size
-      set.draw do |map|
-        map.hello '/hello/world', :controller => 'a', :action => 'b'
-      end
-      assert_equal 1, set.routes.size
-      assert_equal set.routes.first, set.named_routes[:hello]
+  def test_later_named_routes_take_precedence
+    set.draw do |map|
+      map.hello '/hello/world', :controller => 'a', :action => 'b'
+      map.hello '/hello', :controller => 'a', :action => 'b'
     end
+    assert_equal set.routes.last, set.named_routes[:hello]
+  end
 
-    def test_later_named_routes_take_precedence
-      set.draw do |map|
-        map.hello '/hello/world', :controller => 'a', :action => 'b'
-        map.hello '/hello', :controller => 'a', :action => 'b'
-      end
-      assert_equal set.routes.last, set.named_routes[:hello]
+  def setup_named_route_test
+    set.draw do |map|
+      map.show '/people/:id', :controller => 'people', :action => 'show'
+      map.index '/people', :controller => 'people', :action => 'index'
+      map.multi '/people/go/:foo/:bar/joe/:id', :controller => 'people', :action => 'multi'
+      map.users '/admin/users', :controller => 'admin/users', :action => 'index'
     end
 
-    def setup_named_route_test
-      set.draw do |map|
-        map.show '/people/:id', :controller => 'people', :action => 'show'
-        map.index '/people', :controller => 'people', :action => 'index'
-        map.multi '/people/go/:foo/:bar/joe/:id', :controller => 'people', :action => 'multi'
-        map.users '/admin/users', :controller => 'admin/users', :action => 'index'
-      end
+    klass = Class.new(MockController)
+    set.install_helpers(klass)
+    klass.new(set)
+  end
 
-      klass = Class.new(MockController)
-      set.install_helpers(klass)
-      klass.new(set)
-    end
+  def test_named_route_hash_access_method
+    controller = setup_named_route_test
 
-    def test_named_route_hash_access_method
-      controller = setup_named_route_test
+    assert_equal(
+      { :controller => 'people', :action => 'show', :id => 5, :use_route => :show, :only_path => false },
+      controller.send(:hash_for_show_url, :id => 5))
 
-      assert_equal(
-        { :controller => 'people', :action => 'show', :id => 5, :use_route => :show, :only_path => false },
-        controller.send(:hash_for_show_url, :id => 5))
+    assert_equal(
+      { :controller => 'people', :action => 'index', :use_route => :index, :only_path => false },
+      controller.send(:hash_for_index_url))
 
-      assert_equal(
-        { :controller => 'people', :action => 'index', :use_route => :index, :only_path => false },
-        controller.send(:hash_for_index_url))
+    assert_equal(
+      { :controller => 'people', :action => 'show', :id => 5, :use_route => :show, :only_path => true },
+      controller.send(:hash_for_show_path, :id => 5)
+    )
+  end
 
-      assert_equal(
-        { :controller => 'people', :action => 'show', :id => 5, :use_route => :show, :only_path => true },
-        controller.send(:hash_for_show_path, :id => 5)
-      )
-    end
+  def test_named_route_url_method
+    controller = setup_named_route_test
 
-    def test_named_route_url_method
-      controller = setup_named_route_test
+    assert_equal "http://test.host/people/5", controller.send(:show_url, :id => 5)
+    assert_equal "/people/5", controller.send(:show_path, :id => 5)
 
-      assert_equal "http://test.host/people/5", controller.send(:show_url, :id => 5)
-      assert_equal "/people/5", controller.send(:show_path, :id => 5)
+    assert_equal "http://test.host/people", controller.send(:index_url)
+    assert_equal "/people", controller.send(:index_path)
 
-      assert_equal "http://test.host/people", controller.send(:index_url)
-      assert_equal "/people", controller.send(:index_path)
+    assert_equal "http://test.host/admin/users", controller.send(:users_url)
+    assert_equal '/admin/users', controller.send(:users_path)
+    assert_equal '/admin/users', set.generate(controller.send(:hash_for_users_url), {:controller => 'users', :action => 'index'})
+  end
 
-      assert_equal "http://test.host/admin/users", controller.send(:users_url)
-      assert_equal '/admin/users', controller.send(:users_path)
-      assert_equal '/admin/users', set.generate(controller.send(:hash_for_users_url), {:controller => 'users', :action => 'index'})
-    end
+  def test_named_route_url_method_with_anchor
+    controller = setup_named_route_test
 
-    def test_named_route_url_method_with_anchor
-      controller = setup_named_route_test
+    assert_equal "http://test.host/people/5#location", controller.send(:show_url, :id => 5, :anchor => 'location')
+    assert_equal "/people/5#location", controller.send(:show_path, :id => 5, :anchor => 'location')
 
-      assert_equal "http://test.host/people/5#location", controller.send(:show_url, :id => 5, :anchor => 'location')
-      assert_equal "/people/5#location", controller.send(:show_path, :id => 5, :anchor => 'location')
+    assert_equal "http://test.host/people#location", controller.send(:index_url, :anchor => 'location')
+    assert_equal "/people#location", controller.send(:index_path, :anchor => 'location')
 
-      assert_equal "http://test.host/people#location", controller.send(:index_url, :anchor => 'location')
-      assert_equal "/people#location", controller.send(:index_path, :anchor => 'location')
+    assert_equal "http://test.host/admin/users#location", controller.send(:users_url, :anchor => 'location')
+    assert_equal '/admin/users#location', controller.send(:users_path, :anchor => 'location')
 
-      assert_equal "http://test.host/admin/users#location", controller.send(:users_url, :anchor => 'location')
-      assert_equal '/admin/users#location', controller.send(:users_path, :anchor => 'location')
+    assert_equal "http://test.host/people/go/7/hello/joe/5#location",
+      controller.send(:multi_url, 7, "hello", 5, :anchor => 'location')
 
-      assert_equal "http://test.host/people/go/7/hello/joe/5#location",
-        controller.send(:multi_url, 7, "hello", 5, :anchor => 'location')
+    assert_equal "http://test.host/people/go/7/hello/joe/5?baz=bar#location",
+      controller.send(:multi_url, 7, "hello", 5, :baz => "bar", :anchor => 'location')
 
-      assert_equal "http://test.host/people/go/7/hello/joe/5?baz=bar#location",
-        controller.send(:multi_url, 7, "hello", 5, :baz => "bar", :anchor => 'location')
+    assert_equal "http://test.host/people?baz=bar#location",
+      controller.send(:index_url, :baz => "bar", :anchor => 'location')
+  end
 
-      assert_equal "http://test.host/people?baz=bar#location",
-        controller.send(:index_url, :baz => "bar", :anchor => 'location')
-    end
+  def test_named_route_url_method_with_port
+    controller = setup_named_route_test
+    assert_equal "http://test.host:8080/people/5", controller.send(:show_url, 5, :port=>8080)
+  end
 
-    def test_named_route_url_method_with_port
-      controller = setup_named_route_test
-      assert_equal "http://test.host:8080/people/5", controller.send(:show_url, 5, :port=>8080)
-    end
+  def test_named_route_url_method_with_host
+    controller = setup_named_route_test
+    assert_equal "http://some.example.com/people/5", controller.send(:show_url, 5, :host=>"some.example.com")
+  end
 
-    def test_named_route_url_method_with_host
-      controller = setup_named_route_test
-      assert_equal "http://some.example.com/people/5", controller.send(:show_url, 5, :host=>"some.example.com")
-    end
+  def test_named_route_url_method_with_protocol
+    controller = setup_named_route_test
+    assert_equal "https://test.host/people/5", controller.send(:show_url, 5, :protocol => "https")
+  end
 
-    def test_named_route_url_method_with_protocol
-      controller = setup_named_route_test
-      assert_equal "https://test.host/people/5", controller.send(:show_url, 5, :protocol => "https")
-    end
+  def test_named_route_url_method_with_ordered_parameters
+    controller = setup_named_route_test
+    assert_equal "http://test.host/people/go/7/hello/joe/5",
+      controller.send(:multi_url, 7, "hello", 5)
+  end
 
-    def test_named_route_url_method_with_ordered_parameters
-      controller = setup_named_route_test
-      assert_equal "http://test.host/people/go/7/hello/joe/5",
-        controller.send(:multi_url, 7, "hello", 5)
-    end
+  def test_named_route_url_method_with_ordered_parameters_and_hash
+    controller = setup_named_route_test
+    assert_equal "http://test.host/people/go/7/hello/joe/5?baz=bar",
+      controller.send(:multi_url, 7, "hello", 5, :baz => "bar")
+  end
 
-    def test_named_route_url_method_with_ordered_parameters_and_hash
-      controller = setup_named_route_test
-      assert_equal "http://test.host/people/go/7/hello/joe/5?baz=bar",
-        controller.send(:multi_url, 7, "hello", 5, :baz => "bar")
-    end
+  def test_named_route_url_method_with_ordered_parameters_and_empty_hash
+    controller = setup_named_route_test
+    assert_equal "http://test.host/people/go/7/hello/joe/5",
+      controller.send(:multi_url, 7, "hello", 5, {})
+  end
 
-    def test_named_route_url_method_with_ordered_parameters_and_empty_hash
-      controller = setup_named_route_test
-      assert_equal "http://test.host/people/go/7/hello/joe/5",
-        controller.send(:multi_url, 7, "hello", 5, {})
-    end
+  def test_named_route_url_method_with_no_positional_arguments
+    controller = setup_named_route_test
+    assert_equal "http://test.host/people?baz=bar",
+      controller.send(:index_url, :baz => "bar")
+  end
 
-    def test_named_route_url_method_with_no_positional_arguments
-      controller = setup_named_route_test
-      assert_equal "http://test.host/people?baz=bar",
-        controller.send(:index_url, :baz => "bar")
-    end
+  def test_draw_default_route
+    ActionController::Routing.with_controllers(['users']) do
+      set.draw do |map|
+        map.connect '/:controller/:action/:id'
+      end
 
-    def test_draw_default_route
-      ActionController::Routing.with_controllers(['users']) do
-        set.draw do |map|
-          map.connect '/:controller/:action/:id'
-        end
+      assert_equal 1, set.routes.size
+      route = set.routes.first
 
-        assert_equal 1, set.routes.size
-        route = set.routes.first
+      assert route.segments.last.optional?
 
-        assert route.segments.last.optional?
+      assert_equal '/users/show/10', set.generate(:controller => 'users', :action => 'show', :id => 10)
+      assert_equal '/users/index/10', set.generate(:controller => 'users', :id => 10)
 
-        assert_equal '/users/show/10', set.generate(:controller => 'users', :action => 'show', :id => 10)
-        assert_equal '/users/index/10', set.generate(:controller => 'users', :id => 10)
+      assert_equal({:controller => 'users', :action => 'index', :id => '10'}, set.recognize_path('/users/index/10'))
+      assert_equal({:controller => 'users', :action => 'index', :id => '10'}, set.recognize_path('/users/index/10/'))
+    end
+  end
 
-        assert_equal({:controller => 'users', :action => 'index', :id => '10'}, set.recognize_path('/users/index/10'))
-        assert_equal({:controller => 'users', :action => 'index', :id => '10'}, set.recognize_path('/users/index/10/'))
+  def test_draw_default_route_with_default_controller
+    ActionController::Routing.with_controllers(['users']) do
+      set.draw do |map|
+        map.connect '/:controller/:action/:id', :controller => 'users'
       end
+      assert_equal({:controller => 'users', :action => 'index'}, set.recognize_path('/'))
     end
+  end
 
-    def test_draw_default_route_with_default_controller
-      ActionController::Routing.with_controllers(['users']) do
-        set.draw do |map|
-          map.connect '/:controller/:action/:id', :controller => 'users'
-        end
-        assert_equal({:controller => 'users', :action => 'index'}, set.recognize_path('/'))
+  def test_route_with_parameter_shell
+    ActionController::Routing.with_controllers(['users', 'pages']) do
+      set.draw do |map|
+        map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /\d+/
+        map.connect '/:controller/:action/:id'
       end
-    end
 
-    def test_route_with_parameter_shell
-      ActionController::Routing.with_controllers(['users', 'pages']) do
-        set.draw do |map|
-          map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /\d+/
-          map.connect '/:controller/:action/:id'
-        end
+      assert_equal({:controller => 'pages', :action => 'index'}, set.recognize_path('/pages'))
+      assert_equal({:controller => 'pages', :action => 'index'}, set.recognize_path('/pages/index'))
+      assert_equal({:controller => 'pages', :action => 'list'}, set.recognize_path('/pages/list'))
 
-        assert_equal({:controller => 'pages', :action => 'index'}, set.recognize_path('/pages'))
-        assert_equal({:controller => 'pages', :action => 'index'}, set.recognize_path('/pages/index'))
-        assert_equal({:controller => 'pages', :action => 'list'}, set.recognize_path('/pages/list'))
+      assert_equal({:controller => 'pages', :action => 'show', :id => '10'}, set.recognize_path('/pages/show/10'))
+      assert_equal({:controller => 'pages', :action => 'show', :id => '10'}, set.recognize_path('/page/10'))
+    end
+  end
 
-        assert_equal({:controller => 'pages', :action => 'show', :id => '10'}, set.recognize_path('/pages/show/10'))
-        assert_equal({:controller => 'pages', :action => 'show', :id => '10'}, set.recognize_path('/page/10'))
+  def test_route_requirements_with_anchor_chars_are_invalid
+    assert_raise ArgumentError do
+      set.draw do |map|
+        map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /^\d+/
       end
     end
-
-    def test_route_requirements_with_anchor_chars_are_invalid
-      assert_raises ArgumentError do
-        set.draw do |map|
-          map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /^\d+/
-        end
+    assert_raise ArgumentError do
+      set.draw do |map|
+        map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /\A\d+/
       end
-      assert_raises ArgumentError do
-        set.draw do |map|
-          map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /\A\d+/
-        end
+    end
+    assert_raise ArgumentError do
+      set.draw do |map|
+        map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /\d+$/
       end
-      assert_raises ArgumentError do
-        set.draw do |map|
-          map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /\d+$/
-        end
+    end
+    assert_raise ArgumentError do
+      set.draw do |map|
+        map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /\d+\Z/
       end
-      assert_raises ArgumentError do
-        set.draw do |map|
-          map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /\d+\Z/
-        end
+    end
+    assert_raise ArgumentError do
+      set.draw do |map|
+        map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /\d+\z/
       end
-      assert_raises ArgumentError do
-        set.draw do |map|
-          map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /\d+\z/
-        end
+    end
+    assert_nothing_raised do
+      set.draw do |map|
+        map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /\d+/, :name => /^(david|jamis)/
       end
-      assert_nothing_raised do
-        set.draw do |map|
-          map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /\d+/, :name => /^(david|jamis)/
-        end
-        assert_raises ActionController::RoutingError do
-          set.generate :controller => 'pages', :action => 'show', :id => 10
-        end
+      assert_raise ActionController::RoutingError do
+        set.generate :controller => 'pages', :action => 'show', :id => 10
       end
     end
+  end
 
-    def test_route_requirements_with_invalid_http_method_is_invalid
-      assert_raises ArgumentError do
-        set.draw do |map|
-          map.connect 'valid/route', :controller => 'pages', :action => 'show', :conditions => {:method => :invalid}
-        end
+  def test_route_requirements_with_invalid_http_method_is_invalid
+    assert_raise ArgumentError do
+      set.draw do |map|
+        map.connect 'valid/route', :controller => 'pages', :action => 'show', :conditions => {:method => :invalid}
       end
     end
+  end
 
-    def test_route_requirements_with_head_method_condition_is_invalid
-      assert_raises ArgumentError do
-        set.draw do |map|
-          map.connect 'valid/route', :controller => 'pages', :action => 'show', :conditions => {:method => :head}
-        end
+  def test_route_requirements_with_options_method_condition_is_valid
+    assert_nothing_raised do
+      set.draw do |map|
+        map.connect 'valid/route', :controller => 'pages', :action => 'show', :conditions => {:method => :options}
       end
     end
+  end
 
-    def test_non_path_route_requirements_match_all
+  def test_route_requirements_with_head_method_condition_is_invalid
+    assert_raise ArgumentError do
       set.draw do |map|
-        map.connect 'page/37s', :controller => 'pages', :action => 'show', :name => /(jamis|david)/
-      end
-      assert_equal '/page/37s', set.generate(:controller => 'pages', :action => 'show', :name => 'jamis')
-      assert_raises ActionController::RoutingError do
-        set.generate(:controller => 'pages', :action => 'show', :name => 'not_jamis')
-      end
-      assert_raises ActionController::RoutingError do
-        set.generate(:controller => 'pages', :action => 'show', :name => 'nor_jamis_and_david')
+        map.connect 'valid/route', :controller => 'pages', :action => 'show', :conditions => {:method => :head}
       end
     end
+  end
 
-    def test_recognize_with_encoded_id_and_regex
-      set.draw do |map|
-        map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /[a-zA-Z0-9\+]+/
-      end
+  def test_non_path_route_requirements_match_all
+    set.draw do |map|
+      map.connect 'page/37s', :controller => 'pages', :action => 'show', :name => /(jamis|david)/
+    end
+    assert_equal '/page/37s', set.generate(:controller => 'pages', :action => 'show', :name => 'jamis')
+    assert_raise ActionController::RoutingError do
+      set.generate(:controller => 'pages', :action => 'show', :name => 'not_jamis')
+    end
+    assert_raise ActionController::RoutingError do
+      set.generate(:controller => 'pages', :action => 'show', :name => 'nor_jamis_and_david')
+    end
+  end
 
-      assert_equal({:controller => 'pages', :action => 'show', :id => '10'}, set.recognize_path('/page/10'))
-      assert_equal({:controller => 'pages', :action => 'show', :id => 'hello+world'}, set.recognize_path('/page/hello+world'))
+  def test_recognize_with_encoded_id_and_regex
+    set.draw do |map|
+      map.connect 'page/:id', :controller => 'pages', :action => 'show', :id => /[a-zA-Z0-9\+]+/
     end
 
-    def test_recognize_with_conditions
-      Object.const_set(:PeopleController, Class.new)
+    assert_equal({:controller => 'pages', :action => 'show', :id => '10'}, set.recognize_path('/page/10'))
+    assert_equal({:controller => 'pages', :action => 'show', :id => 'hello+world'}, set.recognize_path('/page/hello+world'))
+  end
 
-      set.draw do |map|
-        map.with_options(:controller => "people") do |people|
-          people.people  "/people",     :action => "index",   :conditions => { :method => :get }
-          people.connect "/people",     :action => "create",  :conditions => { :method => :post }
-          people.person  "/people/:id", :action => "show",    :conditions => { :method => :get }
-          people.connect "/people/:id", :action => "update",  :conditions => { :method => :put }
-          people.connect "/people/:id", :action => "destroy", :conditions => { :method => :delete }
-        end
+  def test_recognize_with_conditions
+    Object.const_set(:PeopleController, Class.new)
+
+    set.draw do |map|
+      map.with_options(:controller => "people") do |people|
+        people.people  "/people",     :action => "index",   :conditions => { :method => :get }
+        people.connect "/people",     :action => "create",  :conditions => { :method => :post }
+        people.person  "/people/:id", :action => "show",    :conditions => { :method => :get }
+        people.connect "/people/:id", :action => "update",  :conditions => { :method => :put }
+        people.connect "/people/:id", :action => "destroy", :conditions => { :method => :delete }
       end
+    end
+
+    request.path = "/people"
+    request.env["REQUEST_METHOD"] = "GET"
+    assert_nothing_raised { set.recognize(request) }
+    assert_equal("index", request.path_parameters[:action])
+    request.recycle!
+
+    request.env["REQUEST_METHOD"] = "POST"
+    assert_nothing_raised { set.recognize(request) }
+    assert_equal("create", request.path_parameters[:action])
+    request.recycle!
+
+    request.env["REQUEST_METHOD"] = "PUT"
+    assert_nothing_raised { set.recognize(request) }
+    assert_equal("update", request.path_parameters[:action])
+    request.recycle!
+
+    assert_raise(ActionController::UnknownHttpMethod) {
+      request.env["REQUEST_METHOD"] = "BACON"
+      set.recognize(request)
+    }
+    request.recycle!
+
+    request.path = "/people/5"
+    request.env["REQUEST_METHOD"] = "GET"
+    assert_nothing_raised { set.recognize(request) }
+    assert_equal("show", request.path_parameters[:action])
+    assert_equal("5", request.path_parameters[:id])
+    request.recycle!
+
+    request.env["REQUEST_METHOD"] = "PUT"
+    assert_nothing_raised { set.recognize(request) }
+    assert_equal("update", request.path_parameters[:action])
+    assert_equal("5", request.path_parameters[:id])
+    request.recycle!
 
-      request.path = "/people"
-      request.env["REQUEST_METHOD"] = "GET"
-      assert_nothing_raised { set.recognize(request) }
-      assert_equal("index", request.path_parameters[:action])
-      request.recycle!
+    request.env["REQUEST_METHOD"] = "DELETE"
+    assert_nothing_raised { set.recognize(request) }
+    assert_equal("destroy", request.path_parameters[:action])
+    assert_equal("5", request.path_parameters[:id])
+    request.recycle!
 
+    begin
       request.env["REQUEST_METHOD"] = "POST"
-      assert_nothing_raised { set.recognize(request) }
-      assert_equal("create", request.path_parameters[:action])
-      request.recycle!
-
-      request.env["REQUEST_METHOD"] = "PUT"
-      assert_nothing_raised { set.recognize(request) }
-      assert_equal("update", request.path_parameters[:action])
-      request.recycle!
-
-      assert_raises(ActionController::UnknownHttpMethod) {
-        request.env["REQUEST_METHOD"] = "BACON"
-        set.recognize(request)
-      }
-      request.recycle!
-
-      request.path = "/people/5"
-      request.env["REQUEST_METHOD"] = "GET"
-      assert_nothing_raised { set.recognize(request) }
-      assert_equal("show", request.path_parameters[:action])
-      assert_equal("5", request.path_parameters[:id])
-      request.recycle!
-
-      request.env["REQUEST_METHOD"] = "PUT"
-      assert_nothing_raised { set.recognize(request) }
-      assert_equal("update", request.path_parameters[:action])
-      assert_equal("5", request.path_parameters[:id])
-      request.recycle!
-
-      request.env["REQUEST_METHOD"] = "DELETE"
-      assert_nothing_raised { set.recognize(request) }
-      assert_equal("destroy", request.path_parameters[:action])
-      assert_equal("5", request.path_parameters[:id])
-      request.recycle!
+      set.recognize(request)
+      flunk 'Should have raised MethodNotAllowed'
+    rescue ActionController::MethodNotAllowed => e
+      assert_equal [:get, :put, :delete], e.allowed_methods
+    end
+    request.recycle!
 
-      begin
-        request.env["REQUEST_METHOD"] = "POST"
-        set.recognize(request)
-        flunk 'Should have raised MethodNotAllowed'
-      rescue ActionController::MethodNotAllowed => e
-        assert_equal [:get, :put, :delete], e.allowed_methods
-      end
-      request.recycle!
+  ensure
+    Object.send(:remove_const, :PeopleController)
+  end
 
-    ensure
-      Object.send(:remove_const, :PeopleController)
+  def test_recognize_with_alias_in_conditions
+    Object.const_set(:PeopleController, Class.new)
+
+    set.draw do |map|
+      map.people "/people", :controller => 'people', :action => "index",
+        :conditions => { :method => :get }
+      map.root   :people
     end
 
-    def test_recognize_with_alias_in_conditions
-      Object.const_set(:PeopleController, Class.new)
+    request.path = "/people"
+    request.env["REQUEST_METHOD"] = "GET"
+    assert_nothing_raised { set.recognize(request) }
+    assert_equal("people", request.path_parameters[:controller])
+    assert_equal("index", request.path_parameters[:action])
 
-      set.draw do |map|
-        map.people "/people", :controller => 'people', :action => "index",
-          :conditions => { :method => :get }
-        map.root   :people
-      end
+    request.path = "/"
+    request.env["REQUEST_METHOD"] = "GET"
+    assert_nothing_raised { set.recognize(request) }
+    assert_equal("people", request.path_parameters[:controller])
+    assert_equal("index", request.path_parameters[:action])
+  ensure
+    Object.send(:remove_const, :PeopleController)
+  end
 
-      request.path = "/people"
-      request.env["REQUEST_METHOD"] = "GET"
-      assert_nothing_raised { set.recognize(request) }
-      assert_equal("people", request.path_parameters[:controller])
-      assert_equal("index", request.path_parameters[:action])
+  def test_typo_recognition
+    Object.const_set(:ArticlesController, Class.new)
 
-      request.path = "/"
-      request.env["REQUEST_METHOD"] = "GET"
-      assert_nothing_raised { set.recognize(request) }
-      assert_equal("people", request.path_parameters[:controller])
-      assert_equal("index", request.path_parameters[:action])
-    ensure
-      Object.send(:remove_const, :PeopleController)
+    set.draw do |map|
+      map.connect 'articles/:year/:month/:day/:title',
+             :controller => 'articles', :action => 'permalink',
+             :year => /\d{4}/, :day => /\d{1,2}/, :month => /\d{1,2}/
     end
 
-    def test_typo_recognition
-      Object.const_set(:ArticlesController, Class.new)
-
-      set.draw do |map|
-        map.connect 'articles/:year/:month/:day/:title',
-               :controller => 'articles', :action => 'permalink',
-               :year => /\d{4}/, :day => /\d{1,2}/, :month => /\d{1,2}/
-      end
+    request.path = "/articles/2005/11/05/a-very-interesting-article"
+    request.env["REQUEST_METHOD"] = "GET"
+    assert_nothing_raised { set.recognize(request) }
+    assert_equal("permalink", request.path_parameters[:action])
+    assert_equal("2005", request.path_parameters[:year])
+    assert_equal("11", request.path_parameters[:month])
+    assert_equal("05", request.path_parameters[:day])
+    assert_equal("a-very-interesting-article", request.path_parameters[:title])
 
-      request.path = "/articles/2005/11/05/a-very-interesting-article"
-      request.env["REQUEST_METHOD"] = "GET"
-      assert_nothing_raised { set.recognize(request) }
-      assert_equal("permalink", request.path_parameters[:action])
-      assert_equal("2005", request.path_parameters[:year])
-      assert_equal("11", request.path_parameters[:month])
-      assert_equal("05", request.path_parameters[:day])
-      assert_equal("a-very-interesting-article", request.path_parameters[:title])
+  ensure
+    Object.send(:remove_const, :ArticlesController)
+  end
 
-    ensure
-      Object.send(:remove_const, :ArticlesController)
+  def test_routing_traversal_does_not_load_extra_classes
+    assert !Object.const_defined?("Profiler__"), "Profiler should not be loaded"
+    set.draw do |map|
+      map.connect '/profile', :controller => 'profile'
     end
 
-    def test_routing_traversal_does_not_load_extra_classes
-      assert !Object.const_defined?("Profiler__"), "Profiler should not be loaded"
-      set.draw do |map|
-        map.connect '/profile', :controller => 'profile'
-      end
+    request.path = '/profile'
 
-      request.path = '/profile'
+    set.recognize(request) rescue nil
 
-      set.recognize(request) rescue nil
+    assert !Object.const_defined?("Profiler__"), "Profiler should not be loaded"
+  end
+
+  def test_recognize_with_conditions_and_format
+    Object.const_set(:PeopleController, Class.new)
 
-      assert !Object.const_defined?("Profiler__"), "Profiler should not be loaded"
+    set.draw do |map|
+      map.with_options(:controller => "people") do |people|
+        people.person  "/people/:id", :action => "show",    :conditions => { :method => :get }
+        people.connect "/people/:id", :action => "update",  :conditions => { :method => :put }
+        people.connect "/people/:id.:_format", :action => "show", :conditions => { :method => :get }
+      end
     end
 
-    def test_recognize_with_conditions_and_format
-      Object.const_set(:PeopleController, Class.new)
+    request.path = "/people/5"
+    request.env["REQUEST_METHOD"] = "GET"
+    assert_nothing_raised { set.recognize(request) }
+    assert_equal("show", request.path_parameters[:action])
+    assert_equal("5", request.path_parameters[:id])
+    request.recycle!
 
-      set.draw do |map|
-        map.with_options(:controller => "people") do |people|
-          people.person  "/people/:id", :action => "show",    :conditions => { :method => :get }
-          people.connect "/people/:id", :action => "update",  :conditions => { :method => :put }
-          people.connect "/people/:id.:_format", :action => "show", :conditions => { :method => :get }
-        end
-      end
+    request.env["REQUEST_METHOD"] = "PUT"
+    assert_nothing_raised { set.recognize(request) }
+    assert_equal("update", request.path_parameters[:action])
+    request.recycle!
 
-      request.path = "/people/5"
-      request.env["REQUEST_METHOD"] = "GET"
-      assert_nothing_raised { set.recognize(request) }
-      assert_equal("show", request.path_parameters[:action])
-      assert_equal("5", request.path_parameters[:id])
-      request.recycle!
-
-      request.env["REQUEST_METHOD"] = "PUT"
-      assert_nothing_raised { set.recognize(request) }
-      assert_equal("update", request.path_parameters[:action])
-      request.recycle!
-
-      request.path = "/people/5.png"
-      request.env["REQUEST_METHOD"] = "GET"
-      assert_nothing_raised { set.recognize(request) }
-      assert_equal("show", request.path_parameters[:action])
-      assert_equal("5", request.path_parameters[:id])
-      assert_equal("png", request.path_parameters[:_format])
-    ensure
-      Object.send(:remove_const, :PeopleController)
-    end
-
-    def test_generate_with_default_action
-      set.draw do |map|
-        map.connect "/people", :controller => "people"
-        map.connect "/people/list", :controller => "people", :action => "list"
-      end
+    request.path = "/people/5.png"
+    request.env["REQUEST_METHOD"] = "GET"
+    assert_nothing_raised { set.recognize(request) }
+    assert_equal("show", request.path_parameters[:action])
+    assert_equal("5", request.path_parameters[:id])
+    assert_equal("png", request.path_parameters[:_format])
+  ensure
+    Object.send(:remove_const, :PeopleController)
+  end
 
-      url = set.generate(:controller => "people", :action => "list")
-      assert_equal "/people/list", url
+  def test_generate_with_default_action
+    set.draw do |map|
+      map.connect "/people", :controller => "people"
+      map.connect "/people/list", :controller => "people", :action => "list"
     end
 
-    def test_root_map
-      Object.const_set(:PeopleController, Class.new)
+    url = set.generate(:controller => "people", :action => "list")
+    assert_equal "/people/list", url
+  end
 
-      set.draw { |map| map.root :controller => "people" }
+  def test_root_map
+    Object.const_set(:PeopleController, Class.new)
 
-      request.path = ""
-      request.env["REQUEST_METHOD"] = "GET"
-      assert_nothing_raised { set.recognize(request) }
-      assert_equal("people", request.path_parameters[:controller])
-      assert_equal("index", request.path_parameters[:action])
-    ensure
-      Object.send(:remove_const, :PeopleController)
-    end
+    set.draw { |map| map.root :controller => "people" }
 
-    def test_namespace
-      Object.const_set(:Api, Module.new { |m| m.const_set(:ProductsController, Class.new) })
+    request.path = ""
+    request.env["REQUEST_METHOD"] = "GET"
+    assert_nothing_raised { set.recognize(request) }
+    assert_equal("people", request.path_parameters[:controller])
+    assert_equal("index", request.path_parameters[:action])
+  ensure
+    Object.send(:remove_const, :PeopleController)
+  end
 
-      set.draw do |map|
+  def test_namespace
+    Object.const_set(:Api, Module.new { |m| m.const_set(:ProductsController, Class.new) })
 
-        map.namespace 'api' do |api|
-          api.route 'inventory', :controller => "products", :action => 'inventory'
-        end
+    set.draw do |map|
 
+      map.namespace 'api' do |api|
+        api.route 'inventory', :controller => "products", :action => 'inventory'
       end
 
-      request.path = "/api/inventory"
-      request.env["REQUEST_METHOD"] = "GET"
-      assert_nothing_raised { set.recognize(request) }
-      assert_equal("api/products", request.path_parameters[:controller])
-      assert_equal("inventory", request.path_parameters[:action])
-    ensure
-      Object.send(:remove_const, :Api)
     end
 
-    def test_namespaced_root_map
-      Object.const_set(:Api, Module.new { |m| m.const_set(:ProductsController, Class.new) })
+    request.path = "/api/inventory"
+    request.env["REQUEST_METHOD"] = "GET"
+    assert_nothing_raised { set.recognize(request) }
+    assert_equal("api/products", request.path_parameters[:controller])
+    assert_equal("inventory", request.path_parameters[:action])
+  ensure
+    Object.send(:remove_const, :Api)
+  end
 
-      set.draw do |map|
+  def test_namespaced_root_map
+    Object.const_set(:Api, Module.new { |m| m.const_set(:ProductsController, Class.new) })
 
-        map.namespace 'api' do |api|
-          api.root :controller => "products"
-        end
+    set.draw do |map|
 
+      map.namespace 'api' do |api|
+        api.root :controller => "products"
       end
 
-      request.path = "/api"
-      request.env["REQUEST_METHOD"] = "GET"
-      assert_nothing_raised { set.recognize(request) }
-      assert_equal("api/products", request.path_parameters[:controller])
-      assert_equal("index", request.path_parameters[:action])
-    ensure
-      Object.send(:remove_const, :Api)
     end
 
-    def test_namespace_with_path_prefix
-      Object.const_set(:Api, Module.new { |m| m.const_set(:ProductsController, Class.new) })
-
-      set.draw do |map|
+    request.path = "/api"
+    request.env["REQUEST_METHOD"] = "GET"
+    assert_nothing_raised { set.recognize(request) }
+    assert_equal("api/products", request.path_parameters[:controller])
+    assert_equal("index", request.path_parameters[:action])
+  ensure
+    Object.send(:remove_const, :Api)
+  end
 
-        map.namespace 'api', :path_prefix => 'prefix' do |api|
-          api.route 'inventory', :controller => "products", :action => 'inventory'
-        end
+  def test_namespace_with_path_prefix
+    Object.const_set(:Api, Module.new { |m| m.const_set(:ProductsController, Class.new) })
 
+    set.draw do |map|
+      map.namespace 'api', :path_prefix => 'prefix' do |api|
+        api.route 'inventory', :controller => "products", :action => 'inventory'
       end
-
-      request.path = "/prefix/inventory"
-      request.env["REQUEST_METHOD"] = "GET"
-      assert_nothing_raised { set.recognize(request) }
-      assert_equal("api/products", request.path_parameters[:controller])
-      assert_equal("inventory", request.path_parameters[:action])
-    ensure
-      Object.send(:remove_const, :Api)
     end
 
-    def test_generate_finds_best_fit
-      set.draw do |map|
-        map.connect "/people", :controller => "people", :action => "index"
-        map.connect "/ws/people", :controller => "people", :action => "index", :ws => true
-      end
+    request.path = "/prefix/inventory"
+    request.env["REQUEST_METHOD"] = "GET"
+    assert_nothing_raised { set.recognize(request) }
+    assert_equal("api/products", request.path_parameters[:controller])
+    assert_equal("inventory", request.path_parameters[:action])
+  ensure
+    Object.send(:remove_const, :Api)
+  end
 
-      url = set.generate(:controller => "people", :action => "index", :ws => true)
-      assert_equal "/ws/people", url
-    end
+  def test_namespace_with_blank_path_prefix
+    Object.const_set(:Api, Module.new { |m| m.const_set(:ProductsController, Class.new) })
 
-    def test_generate_changes_controller_module
-      set.draw { |map| map.connect ':controller/:action/:id' }
-      current = { :controller => "bling/bloop", :action => "bap", :id => 9 }
-      url = set.generate({:controller => "foo/bar", :action => "baz", :id => 7}, current)
-      assert_equal "/foo/bar/baz/7", url
+    set.draw do |map|
+      map.namespace 'api', :path_prefix => '' do |api|
+        api.route 'inventory', :controller => "products", :action => 'inventory'
+      end
     end
 
-    def test_id_is_not_impossibly_sticky
-      set.draw do |map|
-        map.connect 'foo/:number', :controller => "people", :action => "index"
-        map.connect ':controller/:action/:id'
-      end
+    request.path = "/inventory"
+    request.env["REQUEST_METHOD"] = "GET"
+    assert_nothing_raised { set.recognize(request) }
+    assert_equal("api/products", request.path_parameters[:controller])
+    assert_equal("inventory", request.path_parameters[:action])
+  ensure
+    Object.send(:remove_const, :Api)
+  end
 
-      url = set.generate({:controller => "people", :action => "index", :number => 3},
-        {:controller => "people", :action => "index", :id => "21"})
-      assert_equal "/foo/3", url
+  def test_generate_finds_best_fit
+    set.draw do |map|
+      map.connect "/people", :controller => "people", :action => "index"
+      map.connect "/ws/people", :controller => "people", :action => "index", :ws => true
     end
 
-    def test_id_is_sticky_when_it_ought_to_be
-      set.draw do |map|
-        map.connect ':controller/:id/:action'
-      end
+    url = set.generate(:controller => "people", :action => "index", :ws => true)
+    assert_equal "/ws/people", url
+  end
 
-      url = set.generate({:action => "destroy"}, {:controller => "people", :action => "show", :id => "7"})
-      assert_equal "/people/7/destroy", url
+  def test_generate_changes_controller_module
+    set.draw { |map| map.connect ':controller/:action/:id' }
+    current = { :controller => "bling/bloop", :action => "bap", :id => 9 }
+    url = set.generate({:controller => "foo/bar", :action => "baz", :id => 7}, current)
+    assert_equal "/foo/bar/baz/7", url
+  end
+
+  def test_id_is_not_impossibly_sticky
+    set.draw do |map|
+      map.connect 'foo/:number', :controller => "people", :action => "index"
+      map.connect ':controller/:action/:id'
     end
 
-    def test_use_static_path_when_possible
-      set.draw do |map|
-        map.connect 'about', :controller => "welcome", :action => "about"
-        map.connect ':controller/:action/:id'
-      end
+    url = set.generate({:controller => "people", :action => "index", :number => 3},
+      {:controller => "people", :action => "index", :id => "21"})
+    assert_equal "/foo/3", url
+  end
 
-      url = set.generate({:controller => "welcome", :action => "about"},
-        {:controller => "welcome", :action => "get", :id => "7"})
-      assert_equal "/about", url
+  def test_id_is_sticky_when_it_ought_to_be
+    set.draw do |map|
+      map.connect ':controller/:id/:action'
     end
 
-    def test_generate
-      set.draw { |map| map.connect ':controller/:action/:id' }
+    url = set.generate({:action => "destroy"}, {:controller => "people", :action => "show", :id => "7"})
+    assert_equal "/people/7/destroy", url
+  end
 
-      args = { :controller => "foo", :action => "bar", :id => "7", :x => "y" }
-      assert_equal "/foo/bar/7?x=y", set.generate(args)
-      assert_equal ["/foo/bar/7", [:x]], set.generate_extras(args)
-      assert_equal [:x], set.extra_keys(args)
+  def test_use_static_path_when_possible
+    set.draw do |map|
+      map.connect 'about', :controller => "welcome", :action => "about"
+      map.connect ':controller/:action/:id'
     end
 
-    def test_generate_with_path_prefix
-      set.draw { |map| map.connect ':controller/:action/:id', :path_prefix => 'my' }
+    url = set.generate({:controller => "welcome", :action => "about"},
+      {:controller => "welcome", :action => "get", :id => "7"})
+    assert_equal "/about", url
+  end
 
-      args = { :controller => "foo", :action => "bar", :id => "7", :x => "y" }
-      assert_equal "/my/foo/bar/7?x=y", set.generate(args)
-    end
+  def test_generate
+    set.draw { |map| map.connect ':controller/:action/:id' }
 
-    def test_named_routes_are_never_relative_to_modules
-      set.draw do |map|
-        map.connect "/connection/manage/:action", :controller => 'connection/manage'
-        map.connect "/connection/connection", :controller => "connection/connection"
-        map.family_connection "/connection", :controller => "connection"
-      end
+    args = { :controller => "foo", :action => "bar", :id => "7", :x => "y" }
+    assert_equal "/foo/bar/7?x=y", set.generate(args)
+    assert_equal ["/foo/bar/7", [:x]], set.generate_extras(args)
+    assert_equal [:x], set.extra_keys(args)
+  end
 
-      url = set.generate({:controller => "connection"}, {:controller => 'connection/manage'})
-      assert_equal "/connection/connection", url
+  def test_generate_with_path_prefix
+    set.draw { |map| map.connect ':controller/:action/:id', :path_prefix => 'my' }
 
-      url = set.generate({:use_route => :family_connection, :controller => "connection"}, {:controller => 'connection/manage'})
-      assert_equal "/connection", url
-    end
+    args = { :controller => "foo", :action => "bar", :id => "7", :x => "y" }
+    assert_equal "/my/foo/bar/7?x=y", set.generate(args)
+  end
 
-    def test_action_left_off_when_id_is_recalled
-      set.draw do |map|
-        map.connect ':controller/:action/:id'
-      end
-      assert_equal '/post', set.generate(
-        {:controller => 'post', :action => 'index'},
-        {:controller => 'post', :action => 'show', :id => '10'}
-      )
+  def test_generate_with_blank_path_prefix
+    set.draw { |map| map.connect ':controller/:action/:id', :path_prefix => '' }
+
+    args = { :controller => "foo", :action => "bar", :id => "7", :x => "y" }
+    assert_equal "/foo/bar/7?x=y", set.generate(args)
+  end
+
+  def test_named_routes_are_never_relative_to_modules
+    set.draw do |map|
+      map.connect "/connection/manage/:action", :controller => 'connection/manage'
+      map.connect "/connection/connection", :controller => "connection/connection"
+      map.family_connection "/connection", :controller => "connection"
     end
 
-    def test_query_params_will_be_shown_when_recalled
-      set.draw do |map|
-        map.connect 'show_post/:parameter', :controller => 'post', :action => 'show'
-        map.connect ':controller/:action/:id'
-      end
-      assert_equal '/post/edit?parameter=1', set.generate(
-        {:action => 'edit', :parameter => 1},
-        {:controller => 'post', :action => 'show', :parameter => 1}
-      )
+    url = set.generate({:controller => "connection"}, {:controller => 'connection/manage'})
+    assert_equal "/connection/connection", url
+
+    url = set.generate({:use_route => :family_connection, :controller => "connection"}, {:controller => 'connection/manage'})
+    assert_equal "/connection", url
+  end
+
+  def test_action_left_off_when_id_is_recalled
+    set.draw do |map|
+      map.connect ':controller/:action/:id'
     end
+    assert_equal '/post', set.generate(
+      {:controller => 'post', :action => 'index'},
+      {:controller => 'post', :action => 'show', :id => '10'}
+    )
+  end
 
-    def test_expiry_determination_should_consider_values_with_to_param
-      set.draw { |map| map.connect 'projects/:project_id/:controller/:action' }
-      assert_equal '/projects/1/post/show', set.generate(
-        {:action => 'show', :project_id => 1},
-        {:controller => 'post', :action => 'show', :project_id => '1'})
+  def test_query_params_will_be_shown_when_recalled
+    set.draw do |map|
+      map.connect 'show_post/:parameter', :controller => 'post', :action => 'show'
+      map.connect ':controller/:action/:id'
     end
+    assert_equal '/post/edit?parameter=1', set.generate(
+      {:action => 'edit', :parameter => 1},
+      {:controller => 'post', :action => 'show', :parameter => 1}
+    )
+  end
 
-    def test_generate_all
-      set.draw do |map|
-        map.connect 'show_post/:id', :controller => 'post', :action => 'show'
-        map.connect ':controller/:action/:id'
-      end
-      all = set.generate(
-        {:action => 'show', :id => 10, :generate_all => true},
-        {:controller => 'post', :action => 'show'}
-      )
-      assert_equal 2, all.length
-      assert_equal '/show_post/10', all.first
-      assert_equal '/post/show/10', all.last
+  def test_format_is_not_inherit
+    set.draw do |map|
+      map.connect '/posts.:format', :controller => 'posts'
     end
 
-    def test_named_route_in_nested_resource
-      set.draw do |map|
-        map.resources :projects do |project|
-          project.milestones 'milestones', :controller => 'milestones', :action => 'index'
-        end
-      end
+    assert_equal '/posts', set.generate(
+      {:controller => 'posts'},
+      {:controller => 'posts', :action => 'index', :format => 'xml'}
+    )
 
-      request.path = "/projects/1/milestones"
-      request.env["REQUEST_METHOD"] = "GET"
-      assert_nothing_raised { set.recognize(request) }
-      assert_equal("milestones", request.path_parameters[:controller])
-      assert_equal("index", request.path_parameters[:action])
-    end
+    assert_equal '/posts.xml', set.generate(
+      {:controller => 'posts', :format => 'xml'},
+      {:controller => 'posts', :action => 'index', :format => 'xml'}
+    )
+  end
 
-    def test_setting_root_in_namespace_using_symbol
-      assert_nothing_raised do
-        set.draw do |map|
-          map.namespace :admin do |admin|
-            admin.root :controller => 'home'
-          end
-        end
-      end
+  def test_expiry_determination_should_consider_values_with_to_param
+    set.draw { |map| map.connect 'projects/:project_id/:controller/:action' }
+    assert_equal '/projects/1/post/show', set.generate(
+      {:action => 'show', :project_id => 1},
+      {:controller => 'post', :action => 'show', :project_id => '1'})
+  end
+
+  def test_generate_all
+    set.draw do |map|
+      map.connect 'show_post/:id', :controller => 'post', :action => 'show'
+      map.connect ':controller/:action/:id'
     end
+    all = set.generate(
+      {:action => 'show', :id => 10, :generate_all => true},
+      {:controller => 'post', :action => 'show'}
+    )
+    assert_equal 2, all.length
+    assert_equal '/show_post/10', all.first
+    assert_equal '/post/show/10', all.last
+  end
 
-    def test_setting_root_in_namespace_using_string
-      assert_nothing_raised do
-        set.draw do |map|
-          map.namespace 'admin' do |admin|
-            admin.root :controller => 'home'
-          end
-        end
+  def test_named_route_in_nested_resource
+    set.draw do |map|
+      map.resources :projects do |project|
+        project.milestones 'milestones', :controller => 'milestones', :action => 'index'
       end
     end
 
-    def test_route_requirements_with_unsupported_regexp_options_must_error
-      assert_raises ArgumentError do
-        set.draw do |map|
-          map.connect 'page/:name', :controller => 'pages',
-            :action => 'show',
-            :requirements => {:name => /(david|jamis)/m}
+    request.path = "/projects/1/milestones"
+    request.env["REQUEST_METHOD"] = "GET"
+    assert_nothing_raised { set.recognize(request) }
+    assert_equal("milestones", request.path_parameters[:controller])
+    assert_equal("index", request.path_parameters[:action])
+  end
+
+  def test_setting_root_in_namespace_using_symbol
+    assert_nothing_raised do
+      set.draw do |map|
+        map.namespace :admin do |admin|
+          admin.root :controller => 'home'
         end
       end
     end
+  end
 
-    def test_route_requirements_with_supported_options_must_not_error
-      assert_nothing_raised do
-        set.draw do |map|
-          map.connect 'page/:name', :controller => 'pages',
-            :action => 'show',
-            :requirements => {:name => /(david|jamis)/i}
-        end
-      end
-      assert_nothing_raised do
-        set.draw do |map|
-          map.connect 'page/:name', :controller => 'pages',
-            :action => 'show',
-            :requirements => {:name => / # Desperately overcommented regexp
-                                        ( #Either
-                                         david #The Creator
-                                        | #Or
-                                          jamis #The Deployer
-                                        )/x}
+  def test_setting_root_in_namespace_using_string
+    assert_nothing_raised do
+      set.draw do |map|
+        map.namespace 'admin' do |admin|
+          admin.root :controller => 'home'
         end
       end
     end
+  end
 
-    def test_route_requirement_recognize_with_ignore_case
+  def test_route_requirements_with_unsupported_regexp_options_must_error
+    assert_raise ArgumentError do
       set.draw do |map|
         map.connect 'page/:name', :controller => 'pages',
           :action => 'show',
-          :requirements => {:name => /(david|jamis)/i}
+          :requirements => {:name => /(david|jamis)/m}
       end
-      assert_equal({:controller => 'pages', :action => 'show', :name => 'jamis'}, set.recognize_path('/page/jamis'))
-      assert_raises ActionController::RoutingError do
-        set.recognize_path('/page/davidjamis')
-      end
-      assert_equal({:controller => 'pages', :action => 'show', :name => 'DAVID'}, set.recognize_path('/page/DAVID'))
     end
+  end
 
-    def test_route_requirement_generate_with_ignore_case
+  def test_route_requirements_with_supported_options_must_not_error
+    assert_nothing_raised do
       set.draw do |map|
         map.connect 'page/:name', :controller => 'pages',
           :action => 'show',
           :requirements => {:name => /(david|jamis)/i}
       end
-      url = set.generate({:controller => 'pages', :action => 'show', :name => 'david'})
-      assert_equal "/page/david", url
-      assert_raises ActionController::RoutingError do
-        url = set.generate({:controller => 'pages', :action => 'show', :name => 'davidjamis'})
-      end
-      url = set.generate({:controller => 'pages', :action => 'show', :name => 'JAMIS'})
-      assert_equal "/page/JAMIS", url
     end
-
-    def test_route_requirement_recognize_with_extended_syntax
+    assert_nothing_raised do
       set.draw do |map|
         map.connect 'page/:name', :controller => 'pages',
           :action => 'show',
@@ -2330,142 +2375,183 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
                                         jamis #The Deployer
                                       )/x}
       end
-      assert_equal({:controller => 'pages', :action => 'show', :name => 'jamis'}, set.recognize_path('/page/jamis'))
-      assert_equal({:controller => 'pages', :action => 'show', :name => 'david'}, set.recognize_path('/page/david'))
-      assert_raises ActionController::RoutingError do
-        set.recognize_path('/page/david #The Creator')
-      end
-      assert_raises ActionController::RoutingError do
-        set.recognize_path('/page/David')
-      end
     end
+  end
 
-    def test_route_requirement_generate_with_extended_syntax
-      set.draw do |map|
-        map.connect 'page/:name', :controller => 'pages',
-          :action => 'show',
-          :requirements => {:name => / # Desperately overcommented regexp
-                                      ( #Either
-                                       david #The Creator
-                                      | #Or
-                                        jamis #The Deployer
-                                      )/x}
-      end
-      url = set.generate({:controller => 'pages', :action => 'show', :name => 'david'})
-      assert_equal "/page/david", url
-      assert_raises ActionController::RoutingError do
-        url = set.generate({:controller => 'pages', :action => 'show', :name => 'davidjamis'})
-      end
-      assert_raises ActionController::RoutingError do
-        url = set.generate({:controller => 'pages', :action => 'show', :name => 'JAMIS'})
-      end
+  def test_route_requirement_recognize_with_ignore_case
+    set.draw do |map|
+      map.connect 'page/:name', :controller => 'pages',
+        :action => 'show',
+        :requirements => {:name => /(david|jamis)/i}
     end
+    assert_equal({:controller => 'pages', :action => 'show', :name => 'jamis'}, set.recognize_path('/page/jamis'))
+    assert_raise ActionController::RoutingError do
+      set.recognize_path('/page/davidjamis')
+    end
+    assert_equal({:controller => 'pages', :action => 'show', :name => 'DAVID'}, set.recognize_path('/page/DAVID'))
+  end
 
-    def test_route_requirement_generate_with_xi_modifiers
-      set.draw do |map|
-        map.connect 'page/:name', :controller => 'pages',
-          :action => 'show',
-          :requirements => {:name => / # Desperately overcommented regexp
-                                      ( #Either
-                                       david #The Creator
-                                      | #Or
-                                        jamis #The Deployer
-                                      )/xi}
-      end
-      url = set.generate({:controller => 'pages', :action => 'show', :name => 'JAMIS'})
-      assert_equal "/page/JAMIS", url
+  def test_route_requirement_generate_with_ignore_case
+    set.draw do |map|
+      map.connect 'page/:name', :controller => 'pages',
+        :action => 'show',
+        :requirements => {:name => /(david|jamis)/i}
+    end
+    url = set.generate({:controller => 'pages', :action => 'show', :name => 'david'})
+    assert_equal "/page/david", url
+    assert_raise ActionController::RoutingError do
+      url = set.generate({:controller => 'pages', :action => 'show', :name => 'davidjamis'})
     end
+    url = set.generate({:controller => 'pages', :action => 'show', :name => 'JAMIS'})
+    assert_equal "/page/JAMIS", url
+  end
 
-    def test_route_requirement_recognize_with_xi_modifiers
-      set.draw do |map|
-        map.connect 'page/:name', :controller => 'pages',
-          :action => 'show',
-          :requirements => {:name => / # Desperately overcommented regexp
-                                      ( #Either
-                                       david #The Creator
-                                      | #Or
-                                        jamis #The Deployer
-                                      )/xi}
-      end
-      assert_equal({:controller => 'pages', :action => 'show', :name => 'JAMIS'}, set.recognize_path('/page/JAMIS'))
+  def test_route_requirement_recognize_with_extended_syntax
+    set.draw do |map|
+      map.connect 'page/:name', :controller => 'pages',
+        :action => 'show',
+        :requirements => {:name => / # Desperately overcommented regexp
+                                    ( #Either
+                                     david #The Creator
+                                    | #Or
+                                      jamis #The Deployer
+                                    )/x}
+    end
+    assert_equal({:controller => 'pages', :action => 'show', :name => 'jamis'}, set.recognize_path('/page/jamis'))
+    assert_equal({:controller => 'pages', :action => 'show', :name => 'david'}, set.recognize_path('/page/david'))
+    assert_raise ActionController::RoutingError do
+      set.recognize_path('/page/david #The Creator')
+    end
+    assert_raise ActionController::RoutingError do
+      set.recognize_path('/page/David')
     end
   end
 
-  class RouteLoadingTest < Test::Unit::TestCase
-    def setup
-      routes.instance_variable_set '@routes_last_modified', nil
-      silence_warnings { Object.const_set :RAILS_ROOT, '.' }
-      routes.add_configuration_file(File.join(RAILS_ROOT, 'config', 'routes.rb'))
+  def test_route_requirement_generate_with_extended_syntax
+    set.draw do |map|
+      map.connect 'page/:name', :controller => 'pages',
+        :action => 'show',
+        :requirements => {:name => / # Desperately overcommented regexp
+                                    ( #Either
+                                     david #The Creator
+                                    | #Or
+                                      jamis #The Deployer
+                                    )/x}
+    end
+    url = set.generate({:controller => 'pages', :action => 'show', :name => 'david'})
+    assert_equal "/page/david", url
+    assert_raise ActionController::RoutingError do
+      url = set.generate({:controller => 'pages', :action => 'show', :name => 'davidjamis'})
+    end
+    assert_raise ActionController::RoutingError do
+      url = set.generate({:controller => 'pages', :action => 'show', :name => 'JAMIS'})
+    end
+  end
 
-      @stat = stub_everything
+  def test_route_requirement_generate_with_xi_modifiers
+    set.draw do |map|
+      map.connect 'page/:name', :controller => 'pages',
+        :action => 'show',
+        :requirements => {:name => / # Desperately overcommented regexp
+                                    ( #Either
+                                     david #The Creator
+                                    | #Or
+                                      jamis #The Deployer
+                                    )/xi}
     end
+    url = set.generate({:controller => 'pages', :action => 'show', :name => 'JAMIS'})
+    assert_equal "/page/JAMIS", url
+  end
 
-    def teardown
-      ActionController::Routing::Routes.configuration_files.clear
-      Object.send :remove_const, :RAILS_ROOT
+  def test_route_requirement_recognize_with_xi_modifiers
+    set.draw do |map|
+      map.connect 'page/:name', :controller => 'pages',
+        :action => 'show',
+        :requirements => {:name => / # Desperately overcommented regexp
+                                    ( #Either
+                                     david #The Creator
+                                    | #Or
+                                      jamis #The Deployer
+                                    )/xi}
     end
+    assert_equal({:controller => 'pages', :action => 'show', :name => 'JAMIS'}, set.recognize_path('/page/JAMIS'))
+  end
+end
 
-    def test_load
-      File.expects(:stat).returns(@stat)
-      routes.expects(:load).with(regexp_matches(/routes\.rb$/))
+class RouteLoadingTest < Test::Unit::TestCase
+  def setup
+    routes.instance_variable_set '@routes_last_modified', nil
+    silence_warnings { Object.const_set :RAILS_ROOT, '.' }
+    routes.add_configuration_file(File.join(RAILS_ROOT, 'config', 'routes.rb'))
 
-      routes.reload
-    end
+    @stat = stub_everything
+  end
 
-    def test_no_reload_when_not_modified
-      @stat.expects(:mtime).times(2).returns(1)
-      File.expects(:stat).times(2).returns(@stat)
-      routes.expects(:load).with(regexp_matches(/routes\.rb$/)).at_most_once
+  def teardown
+    ActionController::Routing::Routes.configuration_files.clear
+    Object.send :remove_const, :RAILS_ROOT
+  end
 
-      2.times { routes.reload }
-    end
+  def test_load
+    File.expects(:stat).returns(@stat)
+    routes.expects(:load).with(regexp_matches(/routes\.rb$/))
 
-    def test_reload_when_modified
-      @stat.expects(:mtime).at_least(2).returns(1, 2)
-      File.expects(:stat).at_least(2).returns(@stat)
-      routes.expects(:load).with(regexp_matches(/routes\.rb$/)).times(2)
+    routes.reload
+  end
 
-      2.times { routes.reload }
-    end
+  def test_no_reload_when_not_modified
+    @stat.expects(:mtime).times(2).returns(1)
+    File.expects(:stat).times(2).returns(@stat)
+    routes.expects(:load).with(regexp_matches(/routes\.rb$/)).at_most_once
 
-    def test_bang_forces_reload
-      @stat.expects(:mtime).at_least(2).returns(1)
-      File.expects(:stat).at_least(2).returns(@stat)
-      routes.expects(:load).with(regexp_matches(/routes\.rb$/)).times(2)
+    2.times { routes.reload }
+  end
 
-      2.times { routes.reload! }
-    end
+  def test_reload_when_modified
+    @stat.expects(:mtime).at_least(2).returns(1, 2)
+    File.expects(:stat).at_least(2).returns(@stat)
+    routes.expects(:load).with(regexp_matches(/routes\.rb$/)).times(2)
 
-    def test_adding_inflections_forces_reload
-      ActiveSupport::Inflector::Inflections.instance.expects(:uncountable).with('equipment')
-      routes.expects(:reload!)
+    2.times { routes.reload }
+  end
 
-      ActiveSupport::Inflector.inflections { |inflect| inflect.uncountable('equipment') }
-    end
+  def test_bang_forces_reload
+    @stat.expects(:mtime).at_least(2).returns(1)
+    File.expects(:stat).at_least(2).returns(@stat)
+    routes.expects(:load).with(regexp_matches(/routes\.rb$/)).times(2)
 
-    def test_load_with_configuration
-      routes.configuration_files.clear
-      routes.add_configuration_file("foobarbaz")
-      File.expects(:stat).returns(@stat)
-      routes.expects(:load).with("foobarbaz")
+    2.times { routes.reload! }
+  end
 
-      routes.reload
-    end
-    
-    def test_load_multiple_configurations
-      routes.add_configuration_file("engines.rb")
-      
-      File.expects(:stat).at_least_once.returns(@stat)
+  def test_adding_inflections_forces_reload
+    ActiveSupport::Inflector::Inflections.instance.expects(:uncountable).with('equipment')
+    routes.expects(:reload!)
 
-      routes.expects(:load).with('./config/routes.rb')
-      routes.expects(:load).with('engines.rb')
+    ActiveSupport::Inflector.inflections { |inflect| inflect.uncountable('equipment') }
+  end
 
-      routes.reload
-    end
+  def test_load_with_configuration
+    routes.configuration_files.clear
+    routes.add_configuration_file("foobarbaz")
+    File.expects(:stat).returns(@stat)
+    routes.expects(:load).with("foobarbaz")
 
-    private
-      def routes
-        ActionController::Routing::Routes
-      end
+    routes.reload
+  end
+  
+  def test_load_multiple_configurations
+    routes.add_configuration_file("engines.rb")
+    
+    File.expects(:stat).at_least_once.returns(@stat)
+
+    routes.expects(:load).with('./config/routes.rb')
+    routes.expects(:load).with('engines.rb')
+
+    routes.reload
   end
+
+  private
+    def routes
+      ActionController::Routing::Routes
+    end
 end
diff --git a/actionpack/test/controller/selector_test.rb b/actionpack/test/controller/selector_test.rb
index 4e31b4573c..9d0613d1e2 100644
--- a/actionpack/test/controller/selector_test.rb
+++ b/actionpack/test/controller/selector_test.rb
@@ -303,7 +303,7 @@ class SelectorTest < Test::Unit::TestCase
     assert_equal 1, @matches.size
     assert_equal "2", @matches[0].attributes["id"]
     # Before first and past last returns nothing.:
-    assert_raises(ArgumentError) { select("tr:nth-child(-1)") }
+    assert_raise(ArgumentError) { select("tr:nth-child(-1)") }
     select("tr:nth-child(0)")
     assert_equal 0, @matches.size
     select("tr:nth-child(5)")
@@ -597,8 +597,8 @@ class SelectorTest < Test::Unit::TestCase
 
   def test_negation_details
     parse(%Q{<p id="1"></p><p id="2"></p><p id="3"></p>})
-    assert_raises(ArgumentError) { select(":not(") }
-    assert_raises(ArgumentError) { select(":not(:not())") }
+    assert_raise(ArgumentError) { select(":not(") }
+    assert_raise(ArgumentError) { select(":not(:not())") }
     select("p:not(#1):not(#3)")
     assert_equal 1, @matches.size
     assert_equal "2", @matches[0].attributes["id"]
diff --git a/actionpack/test/controller/send_file_test.rb b/actionpack/test/controller/send_file_test.rb
index b703f340a0..2e14a0a32c 100644
--- a/actionpack/test/controller/send_file_test.rb
+++ b/actionpack/test/controller/send_file_test.rb
@@ -44,12 +44,12 @@ class SendFileTest < ActionController::TestCase
     response = nil
     assert_nothing_raised { response = process('file') }
     assert_not_nil response
-    assert_kind_of Proc, response.body
+    assert_kind_of Proc, response.body_parts
 
     require 'stringio'
     output = StringIO.new
     output.binmode
-    assert_nothing_raised { response.body.call(response, output) }
+    assert_nothing_raised { response.body_parts.call(response, output) }
     assert_equal file_data, output.string
   end
 
@@ -142,7 +142,7 @@ class SendFileTest < ActionController::TestCase
     }
 
     @controller.headers = {}
-    assert_raises(ArgumentError){ @controller.send(:send_file_headers!, options) }
+    assert_raise(ArgumentError){ @controller.send(:send_file_headers!, options) }
   end
 
   %w(file data).each do |method|
diff --git a/actionpack/test/controller/session/cookie_store_test.rb b/actionpack/test/controller/session/cookie_store_test.rb
index b48a8c3830..9b3f9afb0d 100644
--- a/actionpack/test/controller/session/cookie_store_test.rb
+++ b/actionpack/test/controller/session/cookie_store_test.rb
@@ -24,13 +24,17 @@ class CookieStoreTest < ActionController::IntegrationTest
 
     def set_session_value
       session[:foo] = "bar"
-      render :text => Verifier.generate(session.to_hash)
+      render :text => Rack::Utils.escape(Verifier.generate(session.to_hash))
     end
 
     def get_session_value
       render :text => "foo: #{session[:foo].inspect}"
     end
 
+    def get_session_id
+      render :text => "foo: #{session[:foo].inspect}; id: #{request.session_options[:id]}"
+    end
+
     def call_reset_session
       reset_session
       head :ok
@@ -93,7 +97,7 @@ class CookieStoreTest < ActionController::IntegrationTest
     with_test_route_set do
       get '/set_session_value'
       assert_response :success
-      assert_equal ["_myapp_session=#{response.body}; path=/; httponly"],
+      assert_equal "_myapp_session=#{response.body}; path=/; HttpOnly",
         headers['Set-Cookie']
    end
   end
@@ -107,6 +111,20 @@ class CookieStoreTest < ActionController::IntegrationTest
    end
   end
 
+  def test_getting_session_id
+    with_test_route_set do
+      cookies[SessionKey] = SignedBar
+      get '/persistent_session_id'
+      assert_response :success
+      assert_equal response.body.size, 32
+      session_id = response.body
+
+      get '/get_session_id'
+      assert_response :success
+      assert_equal "foo: \"bar\"; id: #{session_id}", response.body
+    end
+  end
+
   def test_disregards_tampered_sessions
     with_test_route_set do
       cookies[SessionKey] = "BAh7BjoIZm9vIghiYXI%3D--123456780"
@@ -128,7 +146,7 @@ class CookieStoreTest < ActionController::IntegrationTest
     with_test_route_set do
       get '/no_session_access'
       assert_response :success
-      assert_equal [], headers['Set-Cookie']
+      assert_equal "", headers['Set-Cookie']
     end
   end
 
@@ -138,7 +156,7 @@ class CookieStoreTest < ActionController::IntegrationTest
         "fef868465920f415f2c0652d6910d3af288a0367"
       get '/no_session_access'
       assert_response :success
-      assert_equal [], headers['Set-Cookie']
+      assert_equal "", headers['Set-Cookie']
     end
   end
 
@@ -147,7 +165,7 @@ class CookieStoreTest < ActionController::IntegrationTest
       get '/set_session_value'
       assert_response :success
       session_payload = response.body
-      assert_equal ["_myapp_session=#{response.body}; path=/; httponly"],
+      assert_equal "_myapp_session=#{response.body}; path=/; HttpOnly",
         headers['Set-Cookie']
 
       get '/call_reset_session'
@@ -192,7 +210,8 @@ class CookieStoreTest < ActionController::IntegrationTest
       assert_response :success
 
       cookie_body = response.body
-      assert_equal ["_myapp_session=#{cookie_body}; path=/; expires=#{expected_expiry}; httponly"], headers['Set-Cookie']
+      assert_equal "_myapp_session=#{cookie_body}; path=/; expires=#{expected_expiry}; HttpOnly",
+        headers['Set-Cookie']
 
       # Second request does not access the session
       time = Time.local(2008, 4, 25)
@@ -202,7 +221,8 @@ class CookieStoreTest < ActionController::IntegrationTest
       get '/no_session_access'
       assert_response :success
 
-      assert_equal ["_myapp_session=#{cookie_body}; path=/; expires=#{expected_expiry}; httponly"], headers['Set-Cookie']
+      assert_equal "_myapp_session=#{cookie_body}; path=/; expires=#{expected_expiry}; HttpOnly",
+        headers['Set-Cookie']
     end
   end
 
@@ -217,4 +237,13 @@ class CookieStoreTest < ActionController::IntegrationTest
         yield
       end
     end
+
+    def unmarshal_session(cookie_string)
+      session = Rack::Utils.parse_query(cookie_string, ';,').inject({}) {|h,(k,v)|
+        h[k] = Array === v ? v.first : v
+        h
+      }[SessionKey]
+      verifier = ActiveSupport::MessageVerifier.new(SessionSecret, 'SHA1')
+      verifier.verify(session)
+    end
 end
diff --git a/actionpack/test/controller/session/mem_cache_store_test.rb b/actionpack/test/controller/session/mem_cache_store_test.rb
index 2e2bf79148..7561c93e4a 100644
--- a/actionpack/test/controller/session/mem_cache_store_test.rb
+++ b/actionpack/test/controller/session/mem_cache_store_test.rb
@@ -16,8 +16,15 @@ class MemCacheStoreTest < ActionController::IntegrationTest
       render :text => "foo: #{session[:foo].inspect}"
     end
 
+    def get_session_id
+      session[:foo]
+      render :text => "#{request.session_options[:id]}"
+    end
+
     def call_reset_session
+      session[:bar]
       reset_session
+      session[:bar] = "baz"
       head :ok
     end
 
@@ -50,38 +57,56 @@ class MemCacheStoreTest < ActionController::IntegrationTest
       with_test_route_set do
         get '/get_session_value'
         assert_response :success
-      assert_equal 'foo: nil', response.body
+        assert_equal 'foo: nil', response.body
       end
     end
 
-    def test_prevents_session_fixation
+    def test_setting_session_value_after_session_reset
       with_test_route_set do
-        get '/get_session_value'
+        get '/set_session_value'
         assert_response :success
-        assert_equal 'foo: nil', response.body
+        assert cookies['_session_id']
         session_id = cookies['_session_id']
 
-        reset!
+        get '/call_reset_session'
+        assert_response :success
+        assert_not_equal [], headers['Set-Cookie']
 
-        get '/set_session_value', :_session_id => session_id
+        get '/get_session_value'
         assert_response :success
-        assert_equal nil, cookies['_session_id']
+        assert_equal 'foo: nil', response.body
+
+        get '/get_session_id'
+        assert_response :success
+        assert_not_equal session_id, response.body
       end
     end
 
-    def test_setting_session_value_after_session_reset
+    def test_getting_session_id
       with_test_route_set do
         get '/set_session_value'
         assert_response :success
         assert cookies['_session_id']
+        session_id = cookies['_session_id']
 
-        get '/call_reset_session'
+        get '/get_session_id'
         assert_response :success
-        assert_not_equal [], headers['Set-Cookie']
+        assert_equal session_id, response.body
+      end
+    end
 
+    def test_prevents_session_fixation
+      with_test_route_set do
         get '/get_session_value'
         assert_response :success
         assert_equal 'foo: nil', response.body
+        session_id = cookies['_session_id']
+
+        reset!
+
+        get '/set_session_value', :_session_id => session_id
+        assert_response :success
+        assert_equal nil, cookies['_session_id']
       end
     end
   rescue LoadError, RuntimeError
diff --git a/actionpack/test/controller/session/test_session_test.rb b/actionpack/test/controller/session/test_session_test.rb
index 83103be3ec..de6539e1cc 100644
--- a/actionpack/test/controller/session/test_session_test.rb
+++ b/actionpack/test/controller/session/test_session_test.rb
@@ -33,7 +33,7 @@ class ActionController::TestSessionTest < ActiveSupport::TestCase
     assert_equal('value', session[:key])
   end
   
-  def test_calling_delete_removes item
+  def test_calling_delete_removes_item
     session = ActionController::TestSession.new
     session[:key] = 'value'
     assert_equal('value', session[:key])
diff --git a/actionpack/test/controller/test_test.rb b/actionpack/test/controller/test_test.rb
index 55b59d9401..124e259ef6 100644
--- a/actionpack/test/controller/test_test.rb
+++ b/actionpack/test/controller/test_test.rb
@@ -517,6 +517,14 @@ XML
     assert_nil @request.instance_variable_get("@request_method")
   end
 
+  def test_params_reset_after_post_request
+    post :no_op, :foo => "bar"
+    assert_equal "bar", @request.params[:foo]
+    @request.recycle!
+    post :no_op
+    assert @request.params[:foo].blank?
+  end
+
   %w(controller response request).each do |variable|
     %w(get post put delete head process).each do |method|
       define_method("test_#{variable}_missing_for_#{method}_raises_error") do
diff --git a/actionpack/test/controller/url_rewriter_test.rb b/actionpack/test/controller/url_rewriter_test.rb
index 09a8356fec..863f8414c5 100644
--- a/actionpack/test/controller/url_rewriter_test.rb
+++ b/actionpack/test/controller/url_rewriter_test.rb
@@ -99,7 +99,7 @@ class UrlWriterTests < ActionController::TestCase
   end
 
   def test_exception_is_thrown_without_host
-    assert_raises RuntimeError do
+    assert_raise RuntimeError do
       W.new.url_for :controller => 'c', :action => 'a', :id => 'i'
     end
   end