Merge branch 'loofah'

Conflicts:
	Gemfile

14 files changed, 37 insertions, 1772 deletions

diff --git a/actionpack/CHANGELOG.md b/actionpack/CHANGELOG.md
index 67f117454f..ddacbe2aa2 100644
--- a/actionpack/CHANGELOG.md
+++ b/actionpack/CHANGELOG.md
@@ -1,3 +1,7 @@
+*   Deleted the deprecated TagAssertions.
+
+    *Kasper Timm Hansen*
+
 *   Use the Active Support JSON encoder for cookie jars using the `:json` or
     `:hybrid` serializer. This allows you to serialize custom Ruby objects into
     cookies by defining the `#as_json` hook on such objects.
diff --git a/actionpack/actionpack.gemspec b/actionpack/actionpack.gemspec
index d509891fe3..5834e79668 100644
--- a/actionpack/actionpack.gemspec
+++ b/actionpack/actionpack.gemspec
@@ -23,6 +23,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'rack',      '~> 1.6.0.alpha'
   s.add_dependency 'rack-test', '~> 0.6.2'
+  s.add_dependency 'rails-deprecated_sanitizer'
   s.add_dependency 'actionview', version
 
   s.add_development_dependency 'activemodel', version
diff --git a/actionpack/lib/action_controller/test_case.rb b/actionpack/lib/action_controller/test_case.rb
index 152420a54c..8c10c3e7b0 100644
--- a/actionpack/lib/action_controller/test_case.rb
+++ b/actionpack/lib/action_controller/test_case.rb
@@ -3,6 +3,8 @@ require 'active_support/core_ext/object/to_query'
 require 'active_support/core_ext/module/anonymous'
 require 'active_support/core_ext/hash/keys'
 
+require 'rails-dom-testing'
+
 module ActionController
   module TemplateAssertions
     extend ActiveSupport::Concern
@@ -442,6 +444,7 @@ module ActionController
       extend ActiveSupport::Concern
       include ActionDispatch::TestProcess
       include ActiveSupport::Testing::ConstantLookup
+      include Rails::Dom::Testing::Assertions
 
       attr_reader :response, :request
 
@@ -684,6 +687,11 @@ module ActionController
       end
 
       private
+
+      def document_root_element
+        html_document.root
+      end
+
       def check_required_ivars
         # Sanity check for required instance variables so we can give an
         # understandable error message.
diff --git a/actionpack/lib/action_dispatch/testing/assertions.rb b/actionpack/lib/action_dispatch/testing/assertions.rb
index 226baf9ad0..f325c35b57 100644
--- a/actionpack/lib/action_dispatch/testing/assertions.rb
+++ b/actionpack/lib/action_dispatch/testing/assertions.rb
@@ -1,18 +1,22 @@
+require 'rails-dom-testing'
+
 module ActionDispatch
   module Assertions
-    autoload :DomAssertions, 'action_dispatch/testing/assertions/dom'
     autoload :ResponseAssertions, 'action_dispatch/testing/assertions/response'
     autoload :RoutingAssertions, 'action_dispatch/testing/assertions/routing'
-    autoload :SelectorAssertions, 'action_dispatch/testing/assertions/selector'
-    autoload :TagAssertions, 'action_dispatch/testing/assertions/tag'
 
     extend ActiveSupport::Concern
 
-    include DomAssertions
     include ResponseAssertions
     include RoutingAssertions
-    include SelectorAssertions
-    include TagAssertions
+    include Rails::Dom::Testing::Assertions
+
+    def html_document
+      @html_document ||= if @response.content_type =~ /xml$/
+        Nokogiri::XML::Document.parse(@response.body)
+      else
+        Nokogiri::HTML::Document.parse(@response.body)
+      end
+    end
   end
 end
-
diff --git a/actionpack/lib/action_dispatch/testing/assertions/dom.rb b/actionpack/lib/action_dispatch/testing/assertions/dom.rb
index 241a39393a..fb579b52fe 100644
--- a/actionpack/lib/action_dispatch/testing/assertions/dom.rb
+++ b/actionpack/lib/action_dispatch/testing/assertions/dom.rb
@@ -1,27 +1,3 @@
-require 'action_view/vendor/html-scanner'
+require 'active_support/deprecation'
 
-module ActionDispatch
-  module Assertions
-    module DomAssertions
-      # \Test two HTML strings for equivalency (e.g., identical up to reordering of attributes)
-      #
-      #   # assert that the referenced method generates the appropriate HTML string
-      #   assert_dom_equal '<a href="http://www.example.com">Apples</a>', link_to("Apples", "http://www.example.com")
-      def assert_dom_equal(expected, actual, message = nil)
-        expected_dom = HTML::Document.new(expected).root
-        actual_dom   = HTML::Document.new(actual).root
-        assert_equal expected_dom, actual_dom, message
-      end
-
-      # The negated form of +assert_dom_equivalent+.
-      #
-      #   # assert that the referenced method does not generate the specified HTML string
-      #   assert_dom_not_equal '<a href="http://www.example.com">Apples</a>', link_to("Oranges", "http://www.example.com")
-      def assert_dom_not_equal(expected, actual, message = nil)
-        expected_dom = HTML::Document.new(expected).root
-        actual_dom   = HTML::Document.new(actual).root
-        assert_not_equal expected_dom, actual_dom, message
-      end
-    end
-  end
-end
+ActiveSupport::Deprecation.warn("ActionDispatch::Assertions::DomAssertions has been extracted to the rails-dom-testing gem.")
\ No newline at end of file
diff --git a/actionpack/lib/action_dispatch/testing/assertions/selector.rb b/actionpack/lib/action_dispatch/testing/assertions/selector.rb
index 12023e6f77..19eca60f70 100644
--- a/actionpack/lib/action_dispatch/testing/assertions/selector.rb
+++ b/actionpack/lib/action_dispatch/testing/assertions/selector.rb
@@ -1,430 +1,3 @@
-require 'action_view/vendor/html-scanner'
-require 'active_support/core_ext/object/inclusion'
+require 'active_support/deprecation'
 
-#--
-# Copyright (c) 2006 Assaf Arkin (http://labnotes.org)
-# Under MIT and/or CC By license.
-#++
-
-module ActionDispatch
-  module Assertions
-    NO_STRIP = %w{pre script style textarea}
-
-    # Adds the +assert_select+ method for use in Rails functional
-    # test cases, which can be used to make assertions on the response HTML of a controller
-    # action. You can also call +assert_select+ within another +assert_select+ to
-    # make assertions on elements selected by the enclosing assertion.
-    #
-    # Use +css_select+ to select elements without making an assertions, either
-    # from the response HTML or elements selected by the enclosing assertion.
-    #
-    # In addition to HTML responses, you can make the following assertions:
-    #
-    # * +assert_select_encoded+ - Assertions on HTML encoded inside XML, for example for dealing with feed item descriptions.
-    # * +assert_select_email+ - Assertions on the HTML body of an e-mail.
-    #
-    # Also see HTML::Selector to learn how to use selectors.
-    module SelectorAssertions
-      # Select and return all matching elements.
-      #
-      # If called with a single argument, uses that argument as a selector
-      # to match all elements of the current page. Returns an empty array
-      # if no match is found.
-      #
-      # If called with two arguments, uses the first argument as the base
-      # element and the second argument as the selector. Attempts to match the
-      # base element and any of its children. Returns an empty array if no
-      # match is found.
-      #
-      # The selector may be a CSS selector expression (String), an expression
-      # with substitution values (Array) or an HTML::Selector object.
-      #
-      #   # Selects all div tags
-      #   divs = css_select("div")
-      #
-      #   # Selects all paragraph tags and does something interesting
-      #   pars = css_select("p")
-      #   pars.each do |par|
-      #     # Do something fun with paragraphs here...
-      #   end
-      #
-      #   # Selects all list items in unordered lists
-      #   items = css_select("ul>li")
-      #
-      #   # Selects all form tags and then all inputs inside the form
-      #   forms = css_select("form")
-      #   forms.each do |form|
-      #     inputs = css_select(form, "input")
-      #     ...
-      #   end
-      def css_select(*args)
-        # See assert_select to understand what's going on here.
-        arg = args.shift
-
-        if arg.is_a?(HTML::Node)
-          root = arg
-          arg = args.shift
-        elsif arg == nil
-          raise ArgumentError, "First argument is either selector or element to select, but nil found. Perhaps you called assert_select with an element that does not exist?"
-        elsif defined?(@selected) && @selected
-          matches = []
-
-          @selected.each do |selected|
-            subset = css_select(selected, HTML::Selector.new(arg.dup, args.dup))
-            subset.each do |match|
-              matches << match unless matches.any? { |m| m.equal?(match) }
-            end
-          end
-
-          return matches
-        else
-          root = response_from_page
-        end
-
-        case arg
-          when String
-            selector = HTML::Selector.new(arg, args)
-          when Array
-            selector = HTML::Selector.new(*arg)
-          when HTML::Selector
-            selector = arg
-          else raise ArgumentError, "Expecting a selector as the first argument"
-        end
-
-        selector.select(root)
-      end
-
-      # An assertion that selects elements and makes one or more equality tests.
-      #
-      # If the first argument is an element, selects all matching elements
-      # starting from (and including) that element and all its children in
-      # depth-first order.
-      #
-      # If no element if specified, calling +assert_select+ selects from the
-      # response HTML unless +assert_select+ is called from within an +assert_select+ block.
-      #
-      # When called with a block +assert_select+ passes an array of selected elements
-      # to the block. Calling +assert_select+ from the block, with no element specified,
-      # runs the assertion on the complete set of elements selected by the enclosing assertion.
-      # Alternatively the array may be iterated through so that +assert_select+ can be called
-      # separately for each element.
-      #
-      #
-      # ==== Example
-      # If the response contains two ordered lists, each with four list elements then:
-      #   assert_select "ol" do |elements|
-      #     elements.each do |element|
-      #       assert_select element, "li", 4
-      #     end
-      #   end
-      #
-      # will pass, as will:
-      #   assert_select "ol" do
-      #     assert_select "li", 8
-      #   end
-      #
-      # The selector may be a CSS selector expression (String), an expression
-      # with substitution values, or an HTML::Selector object.
-      #
-      # === Equality Tests
-      #
-      # The equality test may be one of the following:
-      # * <tt>true</tt> - Assertion is true if at least one element selected.
-      # * <tt>false</tt> - Assertion is true if no element selected.
-      # * <tt>String/Regexp</tt> - Assertion is true if the text value of at least
-      #   one element matches the string or regular expression.
-      # * <tt>Integer</tt> - Assertion is true if exactly that number of
-      #   elements are selected.
-      # * <tt>Range</tt> - Assertion is true if the number of selected
-      #   elements fit the range.
-      # If no equality test specified, the assertion is true if at least one
-      # element selected.
-      #
-      # To perform more than one equality tests, use a hash with the following keys:
-      # * <tt>:text</tt> - Narrow the selection to elements that have this text
-      #   value (string or regexp).
-      # * <tt>:html</tt> - Narrow the selection to elements that have this HTML
-      #   content (string or regexp).
-      # * <tt>:count</tt> - Assertion is true if the number of selected elements
-      #   is equal to this value.
-      # * <tt>:minimum</tt> - Assertion is true if the number of selected
-      #   elements is at least this value.
-      # * <tt>:maximum</tt> - Assertion is true if the number of selected
-      #   elements is at most this value.
-      #
-      # If the method is called with a block, once all equality tests are
-      # evaluated the block is called with an array of all matched elements.
-      #
-      #   # At least one form element
-      #   assert_select "form"
-      #
-      #   # Form element includes four input fields
-      #   assert_select "form input", 4
-      #
-      #   # Page title is "Welcome"
-      #   assert_select "title", "Welcome"
-      #
-      #   # Page title is "Welcome" and there is only one title element
-      #   assert_select "title", {count: 1, text: "Welcome"},
-      #       "Wrong title or more than one title element"
-      #
-      #   # Page contains no forms
-      #   assert_select "form", false, "This page must contain no forms"
-      #
-      #   # Test the content and style
-      #   assert_select "body div.header ul.menu"
-      #
-      #   # Use substitution values
-      #   assert_select "ol>li#?", /item-\d+/
-      #
-      #   # All input fields in the form have a name
-      #   assert_select "form input" do
-      #     assert_select "[name=?]", /.+/  # Not empty
-      #   end
-      def assert_select(*args, &block)
-        # Start with optional element followed by mandatory selector.
-        arg = args.shift
-        @selected ||= nil
-
-        if arg.is_a?(HTML::Node)
-          # First argument is a node (tag or text, but also HTML root),
-          # so we know what we're selecting from.
-          root = arg
-          arg = args.shift
-        elsif arg == nil
-          # This usually happens when passing a node/element that
-          # happens to be nil.
-          raise ArgumentError, "First argument is either selector or element to select, but nil found. Perhaps you called assert_select with an element that does not exist?"
-        elsif @selected
-          root = HTML::Node.new(nil)
-          root.children.concat @selected
-        else
-          # Otherwise just operate on the response document.
-          root = response_from_page
-        end
-
-        # First or second argument is the selector: string and we pass
-        # all remaining arguments. Array and we pass the argument. Also
-        # accepts selector itself.
-        case arg
-          when String
-            selector = HTML::Selector.new(arg, args)
-          when Array
-            selector = HTML::Selector.new(*arg)
-          when HTML::Selector
-            selector = arg
-          else raise ArgumentError, "Expecting a selector as the first argument"
-        end
-
-        # Next argument is used for equality tests.
-        equals = {}
-        case arg = args.shift
-          when Hash
-            equals = arg
-          when String, Regexp
-            equals[:text] = arg
-          when Integer
-            equals[:count] = arg
-          when Range
-            equals[:minimum] = arg.begin
-            equals[:maximum] = arg.end
-          when FalseClass
-            equals[:count] = 0
-          when NilClass, TrueClass
-            equals[:minimum] = 1
-          else raise ArgumentError, "I don't understand what you're trying to match"
-        end
-
-        # By default we're looking for at least one match.
-        if equals[:count]
-          equals[:minimum] = equals[:maximum] = equals[:count]
-        else
-          equals[:minimum] = 1 unless equals[:minimum]
-        end
-
-        # Last argument is the message we use if the assertion fails.
-        message = args.shift
-        #- message = "No match made with selector #{selector.inspect}" unless message
-        if args.shift
-          raise ArgumentError, "Not expecting that last argument, you either have too many arguments, or they're the wrong type"
-        end
-
-        matches = selector.select(root)
-        # If text/html, narrow down to those elements that match it.
-        content_mismatch = nil
-        if match_with = equals[:text]
-          matches.delete_if do |match|
-            text = ""
-            stack = match.children.reverse
-            while node = stack.pop
-              if node.tag?
-                stack.concat node.children.reverse
-              else
-                content = node.content
-                text << content
-              end
-            end
-            text.strip! unless NO_STRIP.include?(match.name)
-            text.sub!(/\A\n/, '') if match.name == "textarea"
-            unless match_with.is_a?(Regexp) ? (text =~ match_with) : (text == match_with.to_s)
-              content_mismatch ||= sprintf("<%s> expected but was\n<%s>", match_with, text)
-              true
-            end
-          end
-        elsif match_with = equals[:html]
-          matches.delete_if do |match|
-            html = match.children.map(&:to_s).join
-            html.strip! unless NO_STRIP.include?(match.name)
-            unless match_with.is_a?(Regexp) ? (html =~ match_with) : (html == match_with.to_s)
-              content_mismatch ||= sprintf("<%s> expected but was\n<%s>", match_with, html)
-              true
-            end
-          end
-        end
-        # Expecting foo found bar element only if found zero, not if
-        # found one but expecting two.
-        message ||= content_mismatch if matches.empty?
-        # Test minimum/maximum occurrence.
-        min, max, count = equals[:minimum], equals[:maximum], equals[:count]
-
-        # FIXME: minitest provides messaging when we use assert_operator,
-        # so is this custom message really needed?
-        message = message || %(Expected #{count_description(min, max, count)} matching "#{selector.to_s}", found #{matches.size})
-        if count
-          assert_equal count, matches.size, message
-        else
-          assert_operator matches.size, :>=, min, message if min
-          assert_operator matches.size, :<=, max, message if max
-        end
-
-        # If a block is given call that block. Set @selected to allow
-        # nested assert_select, which can be nested several levels deep.
-        if block_given? && !matches.empty?
-          begin
-            in_scope, @selected = @selected, matches
-            yield matches
-          ensure
-            @selected = in_scope
-          end
-        end
-
-        # Returns all matches elements.
-        matches
-      end
-
-      def count_description(min, max, count) #:nodoc:
-        pluralize = lambda {|word, quantity| word << (quantity == 1 ? '' : 's')}
-
-        if min && max && (max != min)
-          "between #{min} and #{max} elements"
-        elsif min && max && max == min && count
-          "exactly #{count} #{pluralize['element', min]}"
-        elsif min && !(min == 1 && max == 1)
-          "at least #{min} #{pluralize['element', min]}"
-        elsif max
-          "at most #{max} #{pluralize['element', max]}"
-        end
-      end
-
-      # Extracts the content of an element, treats it as encoded HTML and runs
-      # nested assertion on it.
-      #
-      # You typically call this method within another assertion to operate on
-      # all currently selected elements. You can also pass an element or array
-      # of elements.
-      #
-      # The content of each element is un-encoded, and wrapped in the root
-      # element +encoded+. It then calls the block with all un-encoded elements.
-      #
-      #   # Selects all bold tags from within the title of an Atom feed's entries (perhaps to nab a section name prefix)
-      #   assert_select "feed[xmlns='http://www.w3.org/2005/Atom']" do
-      #     # Select each entry item and then the title item
-      #     assert_select "entry>title" do
-      #       # Run assertions on the encoded title elements
-      #       assert_select_encoded do
-      #         assert_select "b"
-      #       end
-      #     end
-      #   end
-      #
-      #
-      #   # Selects all paragraph tags from within the description of an RSS feed
-      #   assert_select "rss[version=2.0]" do
-      #     # Select description element of each feed item.
-      #     assert_select "channel>item>description" do
-      #       # Run assertions on the encoded elements.
-      #       assert_select_encoded do
-      #         assert_select "p"
-      #       end
-      #     end
-      #   end
-      def assert_select_encoded(element = nil, &block)
-        case element
-          when Array
-            elements = element
-          when HTML::Node
-            elements = [element]
-          when nil
-            unless elements = @selected
-              raise ArgumentError, "First argument is optional, but must be called from a nested assert_select"
-            end
-          else
-            raise ArgumentError, "Argument is optional, and may be node or array of nodes"
-        end
-
-        fix_content = lambda do |node|
-          # Gets around a bug in the Rails 1.1 HTML parser.
-          node.content.gsub(/<!\[CDATA\[(.*)(\]\]>)?/m) { Rack::Utils.escapeHTML($1) }
-        end
-
-        selected = elements.map do |elem|
-          text = elem.children.select{ |c| not c.tag? }.map{ |c| fix_content[c] }.join
-          root = HTML::Document.new(CGI.unescapeHTML("<encoded>#{text}</encoded>")).root
-          css_select(root, "encoded:root", &block)[0]
-        end
-
-        begin
-          old_selected, @selected = @selected, selected
-          assert_select ":root", &block
-        ensure
-          @selected = old_selected
-        end
-      end
-
-      # Extracts the body of an email and runs nested assertions on it.
-      #
-      # You must enable deliveries for this assertion to work, use:
-      #   ActionMailer::Base.perform_deliveries = true
-      #
-      #  assert_select_email do
-      #    assert_select "h1", "Email alert"
-      #  end
-      #
-      #  assert_select_email do
-      #    items = assert_select "ol>li"
-      #    items.each do
-      #       # Work with items here...
-      #    end
-      #  end
-      def assert_select_email(&block)
-        deliveries = ActionMailer::Base.deliveries
-        assert !deliveries.empty?, "No e-mail in delivery list"
-
-        deliveries.each do |delivery|
-          (delivery.parts.empty? ? [delivery] : delivery.parts).each do |part|
-            if part["Content-Type"].to_s =~ /^text\/html\W/
-              root = HTML::Document.new(part.body.to_s).root
-              assert_select root, ":root", &block
-            end
-          end
-        end
-      end
-
-      protected
-        # +assert_select+ and +css_select+ call this to obtain the content in the HTML page.
-        def response_from_page
-          html_document.root
-        end
-    end
-  end
-end
+ActiveSupport::Deprecation.warn("ActionDispatch::Assertions::SelectorAssertions has been has been extracted to the rails-dom-testing gem.")
\ No newline at end of file
diff --git a/actionpack/lib/action_dispatch/testing/assertions/tag.rb b/actionpack/lib/action_dispatch/testing/assertions/tag.rb
deleted file mode 100644
index e5fe30ba82..0000000000
--- a/actionpack/lib/action_dispatch/testing/assertions/tag.rb
+++ /dev/null
@@ -1,135 +0,0 @@
-require 'action_view/vendor/html-scanner'
-
-module ActionDispatch
-  module Assertions
-    # Pair of assertions to testing elements in the HTML output of the response.
-    module TagAssertions
-      # Asserts that there is a tag/node/element in the body of the response
-      # that meets all of the given conditions. The +conditions+ parameter must
-      # be a hash of any of the following keys (all are optional):
-      #
-      # * <tt>:tag</tt>: the node type must match the corresponding value
-      # * <tt>:attributes</tt>: a hash. The node's attributes must match the
-      #   corresponding values in the hash.
-      # * <tt>:parent</tt>: a hash. The node's parent must match the
-      #   corresponding hash.
-      # * <tt>:child</tt>: a hash. At least one of the node's immediate children
-      #   must meet the criteria described by the hash.
-      # * <tt>:ancestor</tt>: a hash. At least one of the node's ancestors must
-      #   meet the criteria described by the hash.
-      # * <tt>:descendant</tt>: a hash. At least one of the node's descendants
-      #   must meet the criteria described by the hash.
-      # * <tt>:sibling</tt>: a hash. At least one of the node's siblings must
-      #   meet the criteria described by the hash.
-      # * <tt>:after</tt>: a hash. The node must be after any sibling meeting
-      #   the criteria described by the hash, and at least one sibling must match.
-      # * <tt>:before</tt>: a hash. The node must be before any sibling meeting
-      #   the criteria described by the hash, and at least one sibling must match.
-      # * <tt>:children</tt>: a hash, for counting children of a node. Accepts
-      #   the keys:
-      #   * <tt>:count</tt>: either a number or a range which must equal (or
-      #     include) the number of children that match.
-      #   * <tt>:less_than</tt>: the number of matching children must be less
-      #     than this number.
-      #   * <tt>:greater_than</tt>: the number of matching children must be
-      #     greater than this number.
-      #   * <tt>:only</tt>: another hash consisting of the keys to use
-      #     to match on the children, and only matching children will be
-      #     counted.
-      # * <tt>:content</tt>: the textual content of the node must match the
-      #   given value. This will not match HTML tags in the body of a
-      #   tag--only text.
-      #
-      # Conditions are matched using the following algorithm:
-      #
-      # * if the condition is a string, it must be a substring of the value.
-      # * if the condition is a regexp, it must match the value.
-      # * if the condition is a number, the value must match number.to_s.
-      # * if the condition is +true+, the value must not be +nil+.
-      # * if the condition is +false+ or +nil+, the value must be +nil+.
-      #
-      #   # Assert that there is a "span" tag
-      #   assert_tag tag: "span"
-      #
-      #   # Assert that there is a "span" tag with id="x"
-      #   assert_tag tag: "span", attributes: { id: "x" }
-      #
-      #   # Assert that there is a "span" tag using the short-hand
-      #   assert_tag :span
-      #
-      #   # Assert that there is a "span" tag with id="x" using the short-hand
-      #   assert_tag :span, attributes: { id: "x" }
-      #
-      #   # Assert that there is a "span" inside of a "div"
-      #   assert_tag tag: "span", parent: { tag: "div" }
-      #
-      #   # Assert that there is a "span" somewhere inside a table
-      #   assert_tag tag: "span", ancestor: { tag: "table" }
-      #
-      #   # Assert that there is a "span" with at least one "em" child
-      #   assert_tag tag: "span", child: { tag: "em" }
-      #
-      #   # Assert that there is a "span" containing a (possibly nested)
-      #   # "strong" tag.
-      #   assert_tag tag: "span", descendant: { tag: "strong" }
-      #
-      #   # Assert that there is a "span" containing between 2 and 4 "em" tags
-      #   # as immediate children
-      #   assert_tag tag: "span",
-      #              children: { count: 2..4, only: { tag: "em" } }
-      #
-      #   # Get funky: assert that there is a "div", with an "ul" ancestor
-      #   # and an "li" parent (with "class" = "enum"), and containing a
-      #   # "span" descendant that contains text matching /hello world/
-      #   assert_tag tag: "div",
-      #              ancestor: { tag: "ul" },
-      #              parent: { tag: "li",
-      #                           attributes: { class: "enum" } },
-      #              descendant: { tag: "span",
-      #                               child: /hello world/ }
-      #
-      # <b>Please note</b>: +assert_tag+ and +assert_no_tag+ only work
-      # with well-formed XHTML. They recognize a few tags as implicitly self-closing
-      # (like br and hr and such) but will not work correctly with tags
-      # that allow optional closing tags (p, li, td). <em>You must explicitly
-      # close all of your tags to use these assertions.</em>
-      def assert_tag(*opts)
-        opts = opts.size > 1 ? opts.last.merge({ :tag => opts.first.to_s }) : opts.first
-        tag = find_tag(opts)
-        assert tag, "expected tag, but no tag found matching #{opts.inspect} in:\n#{@response.body.inspect}"
-      end
-
-      # Identical to +assert_tag+, but asserts that a matching tag does _not_
-      # exist. (See +assert_tag+ for a full discussion of the syntax.)
-      #
-      #   # Assert that there is not a "div" containing a "p"
-      #   assert_no_tag tag: "div", descendant: { tag: "p" }
-      #
-      #   # Assert that an unordered list is empty
-      #   assert_no_tag tag: "ul", descendant: { tag: "li" }
-      #
-      #   # Assert that there is not a "p" tag with between 1 to 3 "img" tags
-      #   # as immediate children
-      #   assert_no_tag tag: "p",
-      #              children: { count: 1..3, only: { tag: "img" } }
-      def assert_no_tag(*opts)
-        opts = opts.size > 1 ? opts.last.merge({ :tag => opts.first.to_s }) : opts.first
-        tag = find_tag(opts)
-        assert !tag, "expected no tag, but found tag matching #{opts.inspect} in:\n#{@response.body.inspect}"
-      end
-
-      def find_tag(conditions)
-        html_document.find(conditions)
-      end
-
-      def find_all_tag(conditions)
-        html_document.find_all(conditions)
-      end
-
-      def html_document
-        xml = @response.content_type =~ /xml$/
-        @html_document ||= HTML::Document.new(@response.body, false, xml)
-      end
-    end
-  end
-end
diff --git a/actionpack/lib/action_dispatch/testing/integration.rb b/actionpack/lib/action_dispatch/testing/integration.rb
index 192ccdb9d5..2d1c3ac5c7 100644
--- a/actionpack/lib/action_dispatch/testing/integration.rb
+++ b/actionpack/lib/action_dispatch/testing/integration.rb
@@ -495,5 +495,9 @@ module ActionDispatch
       reset! unless integration_session
       integration_session.url_options
     end
+
+    def document_root_element
+      html_document.root
+    end
   end
 end
diff --git a/actionpack/test/controller/action_pack_assertions_test.rb b/actionpack/test/controller/action_pack_assertions_test.rb
index 311302819e..2cf48df6c0 100644
--- a/actionpack/test/controller/action_pack_assertions_test.rb
+++ b/actionpack/test/controller/action_pack_assertions_test.rb
@@ -1,5 +1,4 @@
 require 'abstract_unit'
-require 'action_view/vendor/html-scanner'
 require 'controller/fake_controllers'
 
 class ActionPackAssertionsController < ActionController::Base
@@ -147,11 +146,6 @@ end
 
 class ActionPackAssertionsControllerTest < ActionController::TestCase
 
-  def test_assert_tag_and_url_for
-    get :render_url
-    assert_tag :content => "/action_pack_assertions/flash_me"
-  end
-
   def test_render_file_absolute_path
     get :render_file_absolute_path
     assert_match(/\A= Action Pack/, @response.body)
diff --git a/actionpack/test/controller/assert_select_test.rb b/actionpack/test/controller/assert_select_test.rb
deleted file mode 100644
index f07d201563..0000000000
--- a/actionpack/test/controller/assert_select_test.rb
+++ /dev/null
@@ -1,356 +0,0 @@
-# encoding: utf-8
-#--
-# Copyright (c) 2006 Assaf Arkin (http://labnotes.org)
-# Under MIT and/or CC By license.
-#++
-
-require 'abstract_unit'
-require 'controller/fake_controllers'
-
-require 'action_mailer'
-require 'action_view'
-
-ActionMailer::Base.send(:include, ActionView::Layouts)
-ActionMailer::Base.view_paths = FIXTURE_LOAD_PATH
-
-class AssertSelectTest < ActionController::TestCase
-  Assertion = ActiveSupport::TestCase::Assertion
-
-  class AssertSelectMailer < ActionMailer::Base
-    def test(html)
-      mail :body => html, :content_type => "text/html",
-        :subject => "Test e-mail", :from => "test@test.host", :to => "test <test@test.host>"
-    end
-  end
-
-  class AssertMultipartSelectMailer < ActionMailer::Base
-    def test(options)
-      mail :subject => "Test e-mail", :from => "test@test.host", :to => "test <test@test.host>" do |format|
-        format.text { render :text => options[:text] }
-        format.html { render :text => options[:html] }
-      end
-    end
-  end
-
-  class AssertSelectController < ActionController::Base
-    def response_with=(content)
-      @content = content
-    end
-
-    def response_with(&block)
-      @update = block
-    end
-
-    def html()
-      render :text=>@content, :layout=>false, :content_type=>Mime::HTML
-      @content = nil
-    end
-
-    def xml()
-      render :text=>@content, :layout=>false, :content_type=>Mime::XML
-      @content = nil
-    end
-  end
-
-  tests AssertSelectController
-
-  def setup
-    super
-    @old_delivery_method = ActionMailer::Base.delivery_method
-    @old_perform_deliveries = ActionMailer::Base.perform_deliveries
-    ActionMailer::Base.delivery_method = :test
-    ActionMailer::Base.perform_deliveries = true
-  end
-
-  def teardown
-    super
-    ActionMailer::Base.delivery_method = @old_delivery_method
-    ActionMailer::Base.perform_deliveries = @old_perform_deliveries
-    ActionMailer::Base.deliveries.clear
-  end
-
-  def assert_failure(message, &block)
-    e = assert_raise(Assertion, &block)
-    assert_match(message, e.message) if Regexp === message
-    assert_equal(message, e.message) if String === message
-  end
-
-  #
-  # Test assert select.
-  #
-
-  def test_assert_select
-    render_html %Q{<div id="1"></div><div id="2"></div>}
-    assert_select "div", 2
-    assert_failure(/\AExpected at least 1 element matching \"p\", found 0\.$/) { assert_select "p" }
-  end
-
-  def test_equality_integer
-    render_html %Q{<div id="1"></div><div id="2"></div>}
-    assert_failure(/\AExpected exactly 3 elements matching \"div\", found 2\.$/) { assert_select "div", 3 }
-    assert_failure(/\AExpected exactly 0 elements matching \"div\", found 2\.$/) { assert_select "div", 0 }
-  end
-
-  def test_equality_true_false
-    render_html %Q{<div id="1"></div><div id="2"></div>}
-    assert_nothing_raised    { assert_select "div" }
-    assert_raise(Assertion) { assert_select "p" }
-    assert_nothing_raised    { assert_select "div", true }
-    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_false_message
-    render_html %Q{<div id="1"></div><div id="2"></div>}
-    assert_failure(/\AExpected exactly 0 elements matching \"div\", found 2\.$/) { assert_select "div", 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_raise(Assertion) { assert_select "div", "bar" }
-    assert_failure(/\A<bar> expected but was\n<foo>\.$/) { assert_select "div", "bar" }
-    assert_nothing_raised    { assert_select "div", :text=>"foo" }
-    assert_raise(Assertion) { assert_select "div", :text=>"bar" }
-    assert_nothing_raised    { assert_select "div", /(foo|bar)/ }
-    assert_raise(Assertion) { assert_select "div", /foobar/ }
-    assert_nothing_raised    { assert_select "div", :text=>/(foo|bar)/ }
-    assert_raise(Assertion) { assert_select "div", :text=>/foobar/ }
-    assert_raise(Assertion) { assert_select "p", :text=>/foobar/ }
-  end
-
-  def test_equality_of_html
-    render_html %Q{<p>\n<em>"This is <strong>not</strong> a big problem,"</em> he said.\n</p>}
-    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_raise(Assertion) { assert_select "p", html }
-    assert_nothing_raised    { assert_select "p", :html=>html }
-    assert_raise(Assertion) { assert_select "p", :html=>text }
-    assert_failure(/\A<#{text}> expected but was\n<#{html}>\.$/) { 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_raise(Assertion) { assert_select "pre", html }
-    assert_nothing_raised    { assert_select "pre", :html=>html }
-    assert_raise(Assertion) { assert_select "pre", :html=>text }
-  end
-
-  def test_strip_textarea
-    render_html %Q{<textarea>\n\nfoo\n</textarea>}
-    assert_select "textarea", "\nfoo\n"
-    render_html %Q{<textarea>\nfoo</textarea>}
-    assert_select "textarea", "foo"
-  end
-
-  def test_counts
-    render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
-    assert_nothing_raised               { assert_select "div", 2 }
-    assert_failure(/\AExpected exactly 3 elements matching \"div\", found 2\.$/) do
-      assert_select "div", 3
-    end
-    assert_nothing_raised               { assert_select "div", 1..2 }
-    assert_failure(/\AExpected between 3 and 4 elements matching \"div\", found 2\.$/) do
-      assert_select "div", 3..4
-    end
-    assert_nothing_raised               { assert_select "div", :count=>2 }
-    assert_failure(/\AExpected exactly 3 elements matching \"div\", found 2\.$/) do
-      assert_select "div", :count=>3
-    end
-    assert_nothing_raised               { assert_select "div", :minimum=>1 }
-    assert_nothing_raised               { assert_select "div", :minimum=>2 }
-    assert_failure(/\AExpected at least 3 elements matching \"div\", found 2\.$/) do
-      assert_select "div", :minimum=>3
-    end
-    assert_nothing_raised               { assert_select "div", :maximum=>2 }
-    assert_nothing_raised               { assert_select "div", :maximum=>3 }
-    assert_failure(/\AExpected at most 1 element matching \"div\", found 2\.$/) do
-      assert_select "div", :maximum=>1
-    end
-    assert_nothing_raised               { assert_select "div", :minimum=>1, :maximum=>2 }
-    assert_failure(/\AExpected between 3 and 4 elements matching \"div\", found 2\.$/) do
-      assert_select "div", :minimum=>3, :maximum=>4
-    end
-  end
-
-  def test_substitution_values
-    render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
-    assert_select "div#?", /\d+/ do |elements|
-      assert_equal 2, elements.size
-    end
-    assert_select "div" do
-      assert_select "div#?", /\d+/ do |elements|
-        assert_equal 2, elements.size
-        assert_select "#1"
-        assert_select "#2"
-      end
-    end
-  end
-
-  def test_nested_assert_select
-    render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
-    assert_select "div" do |elements|
-      assert_equal 2, elements.size
-      assert_select elements[0], "#1"
-      assert_select elements[1], "#2"
-    end
-    assert_select "div" do
-      assert_select "div" do |elements|
-        assert_equal 2, elements.size
-        # Testing in a group is one thing
-        assert_select "#1,#2"
-        # Testing individually is another.
-        assert_select "#1"
-        assert_select "#2"
-        assert_select "#3", false
-      end
-    end
-
-    assert_failure(/\AExpected at least 1 element matching \"#4\", found 0\.$/) do
-      assert_select "div" do
-        assert_select "#4"
-      end
-    end
-  end
-
-  def test_assert_select_text_match
-    render_html %Q{<div id="1"><span>foo</span></div><div id="2"><span>bar</span></div>}
-    assert_select "div" do
-      assert_nothing_raised    { assert_select "div", "foo" }
-      assert_nothing_raised    { assert_select "div", "bar" }
-      assert_nothing_raised    { assert_select "div", /\w*/ }
-      assert_nothing_raised    { assert_select "div", :text => /\w*/, :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_raise(Assertion)  { assert_select "div", :html=>"<span>foo</span>", :count=>2 }
-    end
-  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
-
-  #
-  # Test css_select.
-  #
-
-  def test_css_select
-    render_html %Q{<div id="1"></div><div id="2"></div>}
-    assert_equal 2, css_select("div").size
-    assert_equal 0, css_select("p").size
-  end
-
-  def test_nested_css_select
-    render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
-    assert_select "div#?", /\d+/ do |elements|
-      assert_equal 1, css_select(elements[0], "div").size
-      assert_equal 1, css_select(elements[1], "div").size
-    end
-    assert_select "div" do
-      assert_equal 2, css_select("div").size
-      css_select("div").each do |element|
-        # Testing as a group is one thing
-        assert !css_select("#1,#2").empty?
-        # Testing individually is another
-        assert !css_select("#1").empty?
-        assert !css_select("#2").empty?
-      end
-    end
-  end
-
-  def test_feed_item_encoded
-    render_xml <<-EOF
-<rss version="2.0">
-  <channel>
-    <item>
-      <description>
-        <![CDATA[
-          <p>Test 1</p>
-        ]]>
-      </description>
-    </item>
-    <item>
-      <description>
-        <![CDATA[
-          <p>Test 2</p>
-        ]]>
-      </description>
-    </item>
-  </channel>
-</rss>
-EOF
-    assert_select "channel item description" do
-      # Test element regardless of wrapper.
-      assert_select_encoded do
-        assert_select "p", :count=>2, :text=>/Test/
-      end
-      # Test through encoded wrapper.
-      assert_select_encoded do
-        assert_select "encoded p", :count=>2, :text=>/Test/
-      end
-      # Use :root instead (recommended)
-      assert_select_encoded do
-        assert_select ":root p", :count=>2, :text=>/Test/
-      end
-      # Test individually.
-      assert_select "description" do |elements|
-        assert_select_encoded elements[0] do
-          assert_select "p", "Test 1"
-        end
-        assert_select_encoded elements[1] do
-          assert_select "p", "Test 2"
-        end
-      end
-    end
-
-    # Test that we only un-encode element itself.
-    assert_select "channel item" do
-      assert_select_encoded do
-        assert_select "p", 0
-      end
-    end
-  end
-
-  #
-  # Test assert_select_email
-  #
-
-  def test_assert_select_email
-    assert_raise(Assertion) { assert_select_email {} }
-    AssertSelectMailer.test("<div><p>foo</p><p>bar</p></div>").deliver
-    assert_select_email do
-      assert_select "div:root" do
-        assert_select "p:first-child", "foo"
-        assert_select "p:last-child", "bar"
-      end
-    end
-  end
-
-  def test_assert_select_email_multipart
-    AssertMultipartSelectMailer.test(:html => "<div><p>foo</p><p>bar</p></div>", :text => 'foo bar').deliver
-    assert_select_email do
-      assert_select "div:root" do
-        assert_select "p:first-child", "foo"
-        assert_select "p:last-child", "bar"
-      end
-    end
-  end
-
-  protected
-    def render_html(html)
-      @controller.response_with = html
-      get :html
-    end
-
-    def render_xml(xml)
-      @controller.response_with = xml
-      get :xml
-    end
-end
diff --git a/actionpack/test/controller/integration_test.rb b/actionpack/test/controller/integration_test.rb
index 78cce3aa64..99b53e6fd2 100644
--- a/actionpack/test/controller/integration_test.rb
+++ b/actionpack/test/controller/integration_test.rb
@@ -1,6 +1,5 @@
 require 'abstract_unit'
 require 'controller/fake_controllers'
-require 'action_view/vendor/html-scanner'
 require 'rails/engine'
 
 class SessionTest < ActiveSupport::TestCase
@@ -293,7 +292,7 @@ class IntegrationProcessTest < ActionDispatch::IntegrationTest
       assert_equal({}, cookies.to_hash)
       assert_equal "OK", body
       assert_equal "OK", response.body
-      assert_kind_of HTML::Document, html_document
+      assert_kind_of Nokogiri::HTML::Document, html_document
       assert_equal 1, request_count
     end
   end
@@ -309,7 +308,7 @@ class IntegrationProcessTest < ActionDispatch::IntegrationTest
       assert_equal({}, cookies.to_hash)
       assert_equal "Created", body
       assert_equal "Created", response.body
-      assert_kind_of HTML::Document, html_document
+      assert_kind_of Nokogiri::HTML::Document, html_document
       assert_equal 1, request_count
     end
   end
@@ -369,7 +368,7 @@ class IntegrationProcessTest < ActionDispatch::IntegrationTest
       assert_response :redirect
       assert_response :found
       assert_equal "<html><body>You are being <a href=\"http://www.example.com/get\">redirected</a>.</body></html>", response.body
-      assert_kind_of HTML::Document, html_document
+      assert_kind_of Nokogiri::HTML::Document, html_document
       assert_equal 1, request_count
 
       follow_redirect!
diff --git a/actionpack/test/controller/request_forgery_protection_test.rb b/actionpack/test/controller/request_forgery_protection_test.rb
index 2a5aad9c0e..05ad8b6cdc 100644
--- a/actionpack/test/controller/request_forgery_protection_test.rb
+++ b/actionpack/test/controller/request_forgery_protection_test.rb
@@ -389,7 +389,8 @@ class RequestForgeryProtectionControllerUsingResetSessionTest < ActionController
     SecureRandom.stubs(:base64).returns(@token + '<=?')
     get :meta
     assert_select 'meta[name=?][content=?]', 'csrf-param', 'custom_authenticity_token'
-    assert_select 'meta[name=?][content=?]', 'csrf-token', 'cf50faa3fe97702ca1ae&lt;=?'
+    assert_select 'meta[name=?]', 'csrf-token'
+    assert_match(/cf50faa3fe97702ca1ae&lt;=\?/, @response.body)
   end
 end
 
diff --git a/actionpack/test/controller/selector_test.rb b/actionpack/test/controller/selector_test.rb
deleted file mode 100644
index 1e80c8601c..0000000000
--- a/actionpack/test/controller/selector_test.rb
+++ /dev/null
@@ -1,629 +0,0 @@
-#--
-# Copyright (c) 2006 Assaf Arkin (http://labnotes.org)
-# Under MIT and/or CC By license.
-#++
-
-require 'abstract_unit'
-require 'controller/fake_controllers'
-require 'action_view/vendor/html-scanner'
-
-class SelectorTest < ActiveSupport::TestCase
-  #
-  # Basic selector: element, id, class, attributes.
-  #
-
-  def test_element
-    parse(%Q{<div id="1"></div><p></p><div id="2"></div>})
-    # Match element by name.
-    select("div")
-    assert_equal 2, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    assert_equal "2", @matches[1].attributes["id"]
-    # Not case sensitive.
-    select("DIV")
-    assert_equal 2, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    assert_equal "2", @matches[1].attributes["id"]
-    # Universal match (all elements).
-    select("*")
-    assert_equal 3, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    assert_equal nil, @matches[1].attributes["id"]
-    assert_equal "2", @matches[2].attributes["id"]
-  end
-
-
-  def test_identifier
-    parse(%Q{<div id="1"></div><p></p><div id="2"></div>})
-    # Match element by ID.
-    select("div#1")
-    assert_equal 1, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    # Match element by ID, substitute value.
-    select("div#?", 2)
-    assert_equal 1, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    # Element name does not match ID.
-    select("p#?", 2)
-    assert_equal 0, @matches.size
-    # Use regular expression.
-    select("#?", /\d/)
-    assert_equal 2, @matches.size
-  end
-
-
-  def test_class_name
-    parse(%Q{<div id="1" class=" foo "></div><p id="2" class=" foo bar "></p><div id="3" class="bar"></div>})
-    # Match element with specified class.
-    select("div.foo")
-    assert_equal 1, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    # Match any element with specified class.
-    select("*.foo")
-    assert_equal 2, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    assert_equal "2", @matches[1].attributes["id"]
-    # Match elements with other class.
-    select("*.bar")
-    assert_equal 2, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    assert_equal "3", @matches[1].attributes["id"]
-    # Match only element with both class names.
-    select("*.bar.foo")
-    assert_equal 1, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-  end
-
-
-  def test_attribute
-    parse(%Q{<div id="1"></div><p id="2" title="" bar="foo"></p><div id="3" title="foo"></div>})
-    # Match element with attribute.
-    select("div[title]")
-    assert_equal 1, @matches.size
-    assert_equal "3", @matches[0].attributes["id"]
-    # Match any element with attribute.
-    select("*[title]")
-    assert_equal 2, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    assert_equal "3", @matches[1].attributes["id"]
-    # Match element with attribute value.
-    select("*[title=foo]")
-    assert_equal 1, @matches.size
-    assert_equal "3", @matches[0].attributes["id"]
-    # Match element with attribute and attribute value.
-    select("[bar=foo][title]")
-    assert_equal 1, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    # Not case sensitive.
-    select("[BAR=foo][TiTle]")
-    assert_equal 1, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-  end
-
-
-  def test_attribute_quoted
-    parse(%Q{<div id="1" title="foo"></div><div id="2" title="bar"></div><div id="3" title="  bar  "></div>})
-    # Match without quotes.
-    select("[title = bar]")
-    assert_equal 1, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    # Match with single quotes.
-    select("[title = 'bar' ]")
-    assert_equal 1, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    # Match with double quotes.
-    select("[title = \"bar\" ]")
-    assert_equal 1, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    # Match with spaces.
-    select("[title = \"  bar  \" ]")
-    assert_equal 1, @matches.size
-    assert_equal "3", @matches[0].attributes["id"]
-  end
-
-
-  def test_attribute_equality
-    parse(%Q{<div id="1" title="foo bar"></div><div id="2" title="barbaz"></div>})
-    # Match (fail) complete value.
-    select("[title=bar]")
-    assert_equal 0, @matches.size
-    # Match space-separate word.
-    select("[title~=foo]")
-    assert_equal 1, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    select("[title~=bar]")
-    assert_equal 1, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    # Match beginning of value.
-    select("[title^=ba]")
-    assert_equal 1, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    # Match end of value.
-    select("[title$=ar]")
-    assert_equal 1, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    # Match text in value.
-    select("[title*=bar]")
-    assert_equal 2, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    assert_equal "2", @matches[1].attributes["id"]
-    # Match first space separated word.
-    select("[title|=foo]")
-    assert_equal 1, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    select("[title|=bar]")
-    assert_equal 0, @matches.size
-  end
-
-
-  #
-  # Selector composition: groups, sibling, children
-  #
-
-
-  def test_selector_group
-    parse(%Q{<h1 id="1"></h1><h2 id="2"></h2><h3 id="3"></h3>})
-    # Simple group selector.
-    select("h1,h3")
-    assert_equal 2, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    assert_equal "3", @matches[1].attributes["id"]
-    select("h1 , h3")
-    assert_equal 2, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    assert_equal "3", @matches[1].attributes["id"]
-    # Complex group selector.
-    parse(%Q{<h1 id="1"><a href="foo"></a></h1><h2 id="2"><a href="bar"></a></h2><h3 id="2"><a href="baz"></a></h3>})
-    select("h1 a, h3 a")
-    assert_equal 2, @matches.size
-    assert_equal "foo", @matches[0].attributes["href"]
-    assert_equal "baz", @matches[1].attributes["href"]
-    # And now for the three selector challenge.
-    parse(%Q{<h1 id="1"><a href="foo"></a></h1><h2 id="2"><a href="bar"></a></h2><h3 id="2"><a href="baz"></a></h3>})
-    select("h1 a, h2 a, h3 a")
-    assert_equal 3, @matches.size
-    assert_equal "foo", @matches[0].attributes["href"]
-    assert_equal "bar", @matches[1].attributes["href"]
-    assert_equal "baz", @matches[2].attributes["href"]
-  end
-
-
-  def test_sibling_selector
-    parse(%Q{<h1 id="1"></h1><h2 id="2"></h2><h3 id="3"></h3>})
-    # Test next sibling.
-    select("h1+*")
-    assert_equal 1, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    select("h1+h2")
-    assert_equal 1, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    select("h1+h3")
-    assert_equal 0, @matches.size
-    select("*+h3")
-    assert_equal 1, @matches.size
-    assert_equal "3", @matches[0].attributes["id"]
-    # Test any sibling.
-    select("h1~*")
-    assert_equal 2, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    assert_equal "3", @matches[1].attributes["id"]
-    select("h2~*")
-    assert_equal 1, @matches.size
-    assert_equal "3", @matches[0].attributes["id"]
-  end
-
-
-  def test_children_selector
-    parse(%Q{<div><p id="1"><span id="2"></span></p></div><div><p id="3"><span id="4" class="foo"></span></p></div>})
-    # Test child selector.
-    select("div>p")
-    assert_equal 2, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    assert_equal "3", @matches[1].attributes["id"]
-    select("div>span")
-    assert_equal 0, @matches.size
-    select("div>p#3")
-    assert_equal 1, @matches.size
-    assert_equal "3", @matches[0].attributes["id"]
-    select("div>p>span")
-    assert_equal 2, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    assert_equal "4", @matches[1].attributes["id"]
-    # Test descendant selector.
-    select("div p")
-    assert_equal 2, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    assert_equal "3", @matches[1].attributes["id"]
-    select("div span")
-    assert_equal 2, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    assert_equal "4", @matches[1].attributes["id"]
-    select("div *#3")
-    assert_equal 1, @matches.size
-    assert_equal "3", @matches[0].attributes["id"]
-    select("div *#4")
-    assert_equal 1, @matches.size
-    assert_equal "4", @matches[0].attributes["id"]
-    # This is here because it failed before when whitespaces
-    # were not properly stripped.
-    select("div .foo")
-    assert_equal 1, @matches.size
-    assert_equal "4", @matches[0].attributes["id"]
-  end
-
-
-  #
-  # Pseudo selectors: root, nth-child, empty, content, etc
-  #
-
-
-  def test_root_selector
-    parse(%Q{<div id="1"><div id="2"></div></div>})
-    # Can only find element if it's root.
-    select(":root")
-    assert_equal 1, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    select("#1:root")
-    assert_equal 1, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    select("#2:root")
-    assert_equal 0, @matches.size
-    # Opposite for nth-child.
-    select("#1:nth-child(1)")
-    assert_equal 0, @matches.size
-  end
-
-
-  def test_nth_child_odd_even
-    parse(%Q{<table><tr id="1"></tr><tr id="2"></tr><tr id="3"></tr><tr id="4"></tr></table>})
-    # Test odd nth children.
-    select("tr:nth-child(odd)")
-    assert_equal 2, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    assert_equal "3", @matches[1].attributes["id"]
-    # Test even nth children.
-    select("tr:nth-child(even)")
-    assert_equal 2, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    assert_equal "4", @matches[1].attributes["id"]
-  end
-
-
-  def test_nth_child_a_is_zero
-    parse(%Q{<table><tr id="1"></tr><tr id="2"></tr><tr id="3"></tr><tr id="4"></tr></table>})
-    # Test the third child.
-    select("tr:nth-child(0n+3)")
-    assert_equal 1, @matches.size
-    assert_equal "3", @matches[0].attributes["id"]
-    # Same but an can be omitted when zero.
-    select("tr:nth-child(3)")
-    assert_equal 1, @matches.size
-    assert_equal "3", @matches[0].attributes["id"]
-    # Second element (but not every second element).
-    select("tr:nth-child(0n+2)")
-    assert_equal 1, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    # Before first and past last returns nothing.:
-    assert_raise(ArgumentError) { select("tr:nth-child(-1)") }
-    select("tr:nth-child(0)")
-    assert_equal 0, @matches.size
-    select("tr:nth-child(5)")
-    assert_equal 0, @matches.size
-  end
-
-
-  def test_nth_child_a_is_one
-    parse(%Q{<table><tr id="1"></tr><tr id="2"></tr><tr id="3"></tr><tr id="4"></tr></table>})
-    # a is group of one, pick every element in group.
-    select("tr:nth-child(1n+0)")
-    assert_equal 4, @matches.size
-    # Same but a can be omitted when one.
-    select("tr:nth-child(n+0)")
-    assert_equal 4, @matches.size
-    # Same but b can be omitted when zero.
-    select("tr:nth-child(n)")
-    assert_equal 4, @matches.size
-  end
-
-
-  def test_nth_child_b_is_zero
-    parse(%Q{<table><tr id="1"></tr><tr id="2"></tr><tr id="3"></tr><tr id="4"></tr></table>})
-    # If b is zero, pick the n-th element (here each one).
-    select("tr:nth-child(n+0)")
-    assert_equal 4, @matches.size
-    # If b is zero, pick the n-th element (here every second).
-    select("tr:nth-child(2n+0)")
-    assert_equal 2, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    assert_equal "3", @matches[1].attributes["id"]
-    # If a and b are both zero, no element selected.
-    select("tr:nth-child(0n+0)")
-    assert_equal 0, @matches.size
-    select("tr:nth-child(0)")
-    assert_equal 0, @matches.size
-  end
-
-
-  def test_nth_child_a_is_negative
-    parse(%Q{<table><tr id="1"></tr><tr id="2"></tr><tr id="3"></tr><tr id="4"></tr></table>})
-    # Since a is -1, picks the first three elements.
-    select("tr:nth-child(-n+3)")
-    assert_equal 3, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    assert_equal "2", @matches[1].attributes["id"]
-    assert_equal "3", @matches[2].attributes["id"]
-    # Since a is -2, picks the first in every second of first four elements.
-    select("tr:nth-child(-2n+3)")
-    assert_equal 2, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    assert_equal "3", @matches[1].attributes["id"]
-    # Since a is -2, picks the first in every second of first three elements.
-    select("tr:nth-child(-2n+2)")
-    assert_equal 1, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-  end
-
-
-  def test_nth_child_b_is_negative
-    parse(%Q{<table><tr id="1"></tr><tr id="2"></tr><tr id="3"></tr><tr id="4"></tr></table>})
-    # Select last of four.
-    select("tr:nth-child(4n-1)")
-    assert_equal 1, @matches.size
-    assert_equal "4", @matches[0].attributes["id"]
-    # Select first of four.
-    select("tr:nth-child(4n-4)")
-    assert_equal 1, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    # Select last of every second.
-    select("tr:nth-child(2n-1)")
-    assert_equal 2, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    assert_equal "4", @matches[1].attributes["id"]
-    # Select nothing since an+b always < 0
-    select("tr:nth-child(-1n-1)")
-    assert_equal 0, @matches.size
-  end
-
-
-  def test_nth_child_substitution_values
-    parse(%Q{<table><tr id="1"></tr><tr id="2"></tr><tr id="3"></tr><tr id="4"></tr></table>})
-    # Test with ?n?.
-    select("tr:nth-child(?n?)", 2, 1)
-    assert_equal 2, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    assert_equal "3", @matches[1].attributes["id"]
-    select("tr:nth-child(?n?)", 2, 2)
-    assert_equal 2, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    assert_equal "4", @matches[1].attributes["id"]
-    select("tr:nth-child(?n?)", 4, 2)
-    assert_equal 1, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    # Test with ? (b only).
-    select("tr:nth-child(?)", 3)
-    assert_equal 1, @matches.size
-    assert_equal "3", @matches[0].attributes["id"]
-    select("tr:nth-child(?)", 5)
-    assert_equal 0, @matches.size
-  end
-
-
-  def test_nth_last_child
-    parse(%Q{<table><tr id="1"></tr><tr id="2"></tr><tr id="3"></tr><tr id="4"></tr></table>})
-    # Last two elements.
-    select("tr:nth-last-child(-n+2)")
-    assert_equal 2, @matches.size
-    assert_equal "3", @matches[0].attributes["id"]
-    assert_equal "4", @matches[1].attributes["id"]
-    # All old elements counting from last one.
-    select("tr:nth-last-child(odd)")
-    assert_equal 2, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    assert_equal "4", @matches[1].attributes["id"]
-  end
-
-
-  def test_nth_of_type
-    parse(%Q{<table><thead></thead><tr id="1"></tr><tr id="2"></tr><tr id="3"></tr><tr id="4"></tr></table>})
-    # First two elements.
-    select("tr:nth-of-type(-n+2)")
-    assert_equal 2, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    assert_equal "2", @matches[1].attributes["id"]
-    # All old elements counting from last one.
-    select("tr:nth-last-of-type(odd)")
-    assert_equal 2, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    assert_equal "4", @matches[1].attributes["id"]
-  end
-
-
-  def test_first_and_last
-    parse(%Q{<table><thead></thead><tr id="1"></tr><tr id="2"></tr><tr id="3"></tr><tr id="4"></tr></table>})
-    # First child.
-    select("tr:first-child")
-    assert_equal 0, @matches.size
-    select(":first-child")
-    assert_equal 1, @matches.size
-    assert_equal "thead", @matches[0].name
-    # First of type.
-    select("tr:first-of-type")
-    assert_equal 1, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    select("thead:first-of-type")
-    assert_equal 1, @matches.size
-    assert_equal "thead", @matches[0].name
-    select("div:first-of-type")
-    assert_equal 0, @matches.size
-    # Last child.
-    select("tr:last-child")
-    assert_equal 1, @matches.size
-    assert_equal "4", @matches[0].attributes["id"]
-    # Last of type.
-    select("tr:last-of-type")
-    assert_equal 1, @matches.size
-    assert_equal "4", @matches[0].attributes["id"]
-    select("thead:last-of-type")
-    assert_equal 1, @matches.size
-    assert_equal "thead", @matches[0].name
-    select("div:last-of-type")
-    assert_equal 0, @matches.size
-  end
-
-
-  def test_only_child_and_only_type_first_and_last
-    # Only child.
-    parse(%Q{<table><tr></tr></table>})
-    select("table:only-child")
-    assert_equal 0, @matches.size
-    select("tr:only-child")
-    assert_equal 1, @matches.size
-    assert_equal "tr", @matches[0].name
-    parse(%Q{<table><tr></tr><tr></tr></table>})
-    select("tr:only-child")
-    assert_equal 0, @matches.size
-    # Only of type.
-    parse(%Q{<table><thead></thead><tr></tr><tr></tr></table>})
-    select("thead:only-of-type")
-    assert_equal 1, @matches.size
-    assert_equal "thead", @matches[0].name
-    select("td:only-of-type")
-    assert_equal 0, @matches.size
-  end
-
-
-  def test_empty
-    parse(%Q{<table><tr></tr></table>})
-    select("table:empty")
-    assert_equal 0, @matches.size
-    select("tr:empty")
-    assert_equal 1, @matches.size
-    parse(%Q{<div> </div>})
-    select("div:empty")
-    assert_equal 1, @matches.size
-  end
-
-
-  def test_content
-    parse(%Q{<div> </div>})
-    select("div:content()")
-    assert_equal 1, @matches.size
-    parse(%Q{<div>something </div>})
-    select("div:content()")
-    assert_equal 0, @matches.size
-    select("div:content(something)")
-    assert_equal 1, @matches.size
-    select("div:content( 'something' )")
-    assert_equal 1, @matches.size
-    select("div:content( \"something\" )")
-    assert_equal 1, @matches.size
-    select("div:content(?)", "something")
-    assert_equal 1, @matches.size
-    select("div:content(?)", /something/)
-    assert_equal 1, @matches.size
-  end
-
-
-  #
-  # Test negation.
-  #
-
-
-  def test_element_negation
-    parse(%Q{<p></p><div></div>})
-    select("*")
-    assert_equal 2, @matches.size
-    select("*:not(p)")
-    assert_equal 1, @matches.size
-    assert_equal "div", @matches[0].name
-    select("*:not(div)")
-    assert_equal 1, @matches.size
-    assert_equal "p", @matches[0].name
-    select("*:not(span)")
-    assert_equal 2, @matches.size
-  end
-
-
-  def test_id_negation
-    parse(%Q{<p id="1"></p><p id="2"></p>})
-    select("p")
-    assert_equal 2, @matches.size
-    select(":not(#1)")
-    assert_equal 1, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    select(":not(#2)")
-    assert_equal 1, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-  end
-
-
-  def test_class_name_negation
-    parse(%Q{<p class="foo"></p><p class="bar"></p>})
-    select("p")
-    assert_equal 2, @matches.size
-    select(":not(.foo)")
-    assert_equal 1, @matches.size
-    assert_equal "bar", @matches[0].attributes["class"]
-    select(":not(.bar)")
-    assert_equal 1, @matches.size
-    assert_equal "foo", @matches[0].attributes["class"]
-  end
-
-
-  def test_attribute_negation
-    parse(%Q{<p title="foo"></p><p title="bar"></p>})
-    select("p")
-    assert_equal 2, @matches.size
-    select(":not([title=foo])")
-    assert_equal 1, @matches.size
-    assert_equal "bar", @matches[0].attributes["title"]
-    select(":not([title=bar])")
-    assert_equal 1, @matches.size
-    assert_equal "foo", @matches[0].attributes["title"]
-  end
-
-
-  def test_pseudo_class_negation
-    parse(%Q{<div><p id="1"></p><p id="2"></p></div>})
-    select("p")
-    assert_equal 2, @matches.size
-    select("p:not(:first-child)")
-    assert_equal 1, @matches.size
-    assert_equal "2", @matches[0].attributes["id"]
-    select("p:not(:nth-child(2))")
-    assert_equal 1, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-  end
-
-
-  def test_negation_details
-    parse(%Q{<p id="1"></p><p id="2"></p><p id="3"></p>})
-    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"]
-  end
-
-
-  def test_select_from_element
-    parse(%Q{<div><p id="1"></p><p id="2"></p></div>})
-    select("div")
-    @matches = @matches[0].select("p")
-    assert_equal 2, @matches.size
-    assert_equal "1", @matches[0].attributes["id"]
-    assert_equal "2", @matches[1].attributes["id"]
-  end
-
-
-protected
-
-  def parse(html)
-    @html = HTML::Document.new(html).root
-  end
-
-  def select(*selector)
-    @matches = HTML.selector(*selector).select(@html)
-  end
-
-end
diff --git a/actionpack/test/controller/test_case_test.rb b/actionpack/test/controller/test_case_test.rb
index 060c940100..1280e0d9a3 100644
--- a/actionpack/test/controller/test_case_test.rb
+++ b/actionpack/test/controller/test_case_test.rb
@@ -353,168 +353,6 @@ XML
     assert_equal "bar", assigns[:bar]
   end
 
-  def test_assert_tag_tag
-    process :test_html_output
-
-    # there is a 'form' tag
-    assert_tag :tag => 'form'
-    # there is not an 'hr' tag
-    assert_no_tag :tag => 'hr'
-  end
-
-  def test_assert_tag_attributes
-    process :test_html_output
-
-    # there is a tag with an 'id' of 'bar'
-    assert_tag :attributes => { :id => "bar" }
-    # there is no tag with a 'name' of 'baz'
-    assert_no_tag :attributes => { :name => "baz" }
-  end
-
-  def test_assert_tag_parent
-    process :test_html_output
-
-    # there is a tag with a parent 'form' tag
-    assert_tag :parent => { :tag => "form" }
-    # there is no tag with a parent of 'input'
-    assert_no_tag :parent => { :tag => "input" }
-  end
-
-  def test_assert_tag_child
-    process :test_html_output
-
-    # there is a tag with a child 'input' tag
-    assert_tag :child => { :tag => "input" }
-    # there is no tag with a child 'strong' tag
-    assert_no_tag :child => { :tag => "strong" }
-  end
-
-  def test_assert_tag_ancestor
-    process :test_html_output
-
-    # there is a 'li' tag with an ancestor having an id of 'foo'
-    assert_tag :ancestor => { :attributes => { :id => "foo" } }, :tag => "li"
-    # there is no tag of any kind with an ancestor having an href matching 'foo'
-    assert_no_tag :ancestor => { :attributes => { :href => /foo/ } }
-  end
-
-  def test_assert_tag_descendant
-    process :test_html_output
-
-    # there is a tag with a descendant 'li' tag
-    assert_tag :descendant => { :tag => "li" }
-    # there is no tag with a descendant 'html' tag
-    assert_no_tag :descendant => { :tag => "html" }
-  end
-
-  def test_assert_tag_sibling
-    process :test_html_output
-
-    # there is a tag with a sibling of class 'item'
-    assert_tag :sibling => { :attributes => { :class => "item" } }
-    # there is no tag with a sibling 'ul' tag
-    assert_no_tag :sibling => { :tag => "ul" }
-  end
-
-  def test_assert_tag_after
-    process :test_html_output
-
-    # there is a tag following a sibling 'div' tag
-    assert_tag :after => { :tag => "div" }
-    # there is no tag following a sibling tag with id 'bar'
-    assert_no_tag :after => { :attributes => { :id => "bar" } }
-  end
-
-  def test_assert_tag_before
-    process :test_html_output
-
-    # there is a tag preceding a tag with id 'bar'
-    assert_tag :before => { :attributes => { :id => "bar" } }
-    # there is no tag preceding a 'form' tag
-    assert_no_tag :before => { :tag => "form" }
-  end
-
-  def test_assert_tag_children_count
-    process :test_html_output
-
-    # there is a tag with 2 children
-    assert_tag :children => { :count => 2 }
-    # in particular, there is a <ul> tag with two children (a nameless pair of <li>s)
-    assert_tag :tag => 'ul', :children => { :count => 2 }
-    # there is no tag with 4 children
-    assert_no_tag :children => { :count => 4 }
-  end
-
-  def test_assert_tag_children_less_than
-    process :test_html_output
-
-    # there is a tag with less than 5 children
-    assert_tag :children => { :less_than => 5 }
-    # there is no 'ul' tag with less than 2 children
-    assert_no_tag :children => { :less_than => 2 }, :tag => "ul"
-  end
-
-  def test_assert_tag_children_greater_than
-    process :test_html_output
-
-    # there is a 'body' tag with more than 1 children
-    assert_tag :children => { :greater_than => 1 }, :tag => "body"
-    # there is no tag with more than 10 children
-    assert_no_tag :children => { :greater_than => 10 }
-  end
-
-  def test_assert_tag_children_only
-    process :test_html_output
-
-    # there is a tag containing only one child with an id of 'foo'
-    assert_tag :children => { :count => 1,
-                              :only => { :attributes => { :id => "foo" } } }
-    # there is no tag containing only one 'li' child
-    assert_no_tag :children => { :count => 1, :only => { :tag => "li" } }
-  end
-
-  def test_assert_tag_content
-    process :test_html_output
-
-    # the output contains the string "Name"
-    assert_tag :content => /Name/
-    # the output does not contain the string "test"
-    assert_no_tag :content => /test/
-  end
-
-  def test_assert_tag_multiple
-    process :test_html_output
-
-    # there is a 'div', id='bar', with an immediate child whose 'action'
-    # attribute matches the regexp /somewhere/.
-    assert_tag :tag => "div", :attributes => { :id => "bar" },
-               :child => { :attributes => { :action => /somewhere/ } }
-
-    # there is no 'div', id='foo', with a 'ul' child with more than
-    # 2 "li" children.
-    assert_no_tag :tag => "div", :attributes => { :id => "foo" },
-                  :child => {
-                    :tag => "ul",
-                    :children => { :greater_than => 2,
-                                   :only => { :tag => "li" } } }
-  end
-
-  def test_assert_tag_children_without_content
-    process :test_html_output
-
-    # there is a form tag with an 'input' child which is a self closing tag
-    assert_tag :tag => "form",
-      :children => { :count => 1,
-        :only => { :tag => "input" } }
-
-    # the body tag has an 'a' child which in turn has an 'img' child
-    assert_tag :tag => "body",
-      :children => { :count => 1,
-        :only => { :tag => "a",
-          :children => { :count => 1,
-            :only => { :tag => "img" } } } }
-  end
-
   def test_should_not_impose_childless_html_tags_in_xml
     process :test_xml_output
 
@@ -529,23 +367,6 @@ XML
     assert err.empty?
   end
 
-  def test_assert_tag_attribute_matching
-    @response.body = '<input type="text" name="my_name">'
-    assert_tag :tag => 'input',
-                 :attributes => { :name => /my/, :type => 'text' }
-    assert_no_tag :tag => 'input',
-                 :attributes => { :name => 'my', :type => 'text' }
-    assert_no_tag :tag => 'input',
-                 :attributes => { :name => /^my$/, :type => 'text' }
-  end
-
-  def test_assert_tag_content_matching
-    @response.body = "<p>hello world</p>"
-    assert_tag :tag => "p", :content => "hello world"
-    assert_tag :tag => "p", :content => /hello/
-    assert_no_tag :tag => "p", :content => "hello"
-  end
-
   def test_assert_generates
     assert_generates 'controller/action/5', :controller => 'controller', :action => 'action', :id => '5'
     assert_generates 'controller/action/7', {:id => "7"}, {:controller => "controller", :action => "action"}