Wed Aug  8 08:41:45 EST 2007  Matt Palmer <mpalmer@hezmatt.org>
  * A completely running test suite for assert_elements.  Includes a fair amount of reworked code, to fit the existing API for assert_select
diff -rN -u old-testsuite/lib/hpricot_test_helper.rb new-testsuite/lib/hpricot_test_helper.rb
--- old-testsuite/lib/hpricot_test_helper.rb	2008-10-20 23:31:06.523878423 +1100
+++ new-testsuite/lib/hpricot_test_helper.rb	2008-10-20 23:31:06.531857422 +1100
@@ -42,28 +42,78 @@
     els
   end
   
-  def assert_elements css_query, equality = nil, &block
+  def assert_elements *args, &block
+    # Is the first argument the element to search within?
+    if args[0].is_a? Hpricot::Elem
+      els = [args.shift]
+    elsif args[0].nil?
+      # This can happen if the user passes in what they think is an element,
+      # but it happened to be nil
+      raise ArgumentError, "The first argument to assert_elements should either be an element or a CSS selector, but nil found.  Perhaps you called assert_elements with an element that doesn't exist?"
+    end
+
+    css_query = args.shift
+    equality = args.shift
+    extra_equalities = args.empty? ? {} : args[0].is_a?(Hash) ? args.shift : {}
+    
+    raise ArgumentError, "Too many arguments given to assert_elements.  Extra arguments were #{args.inspect}" unless args.empty?
+
     message = equality.delete(:message) if equality.is_a?(Hash)
 
     case equality
       when Numeric then equality = {:count => equality}
       when Range then equality = {:minimum => equality.to_a.first, :maximum => equality.to_a.last }
-      else equality ||= {}
+      when String then equality = {:text => equality}
+      when Regexp then equality = {:text => equality}
+      when NilClass then equality = {:minimum => 1}
+      when TrueClass then equality = {:minimum => 1}
+      when FalseClass then equality = {:count => 0}
+      when Hash then nil
+      else raise ArgumentError.new("Unknown type for equality specification, #{equality.class}")
     end
+
+    equality.merge(extra_equalities)
+
+    els = get_elements(css_query, equality[:text]) if els.nil?
+
+    # Filter elements further than the simple CSS query would suggest
     
-    equality.merge!({:minimum => 1}) if (equality.keys & [:minimum, :maximum, :count]).empty?
-    
-    els = get_elements(css_query, equality[:text])
+    # FIXME: This text filter looks like it should be handled by get_elements,
+    # above.  After the test suite is working, try removing this and see if it
+    # breaks anything, and consider trying to work the equality[:html] filter
+    # into get_elements as well.
+    if equality.keys.include?(:text)
+    	els = els.find_all {|e| equality[:text].is_a?(Regexp) ? e.inner_text =~ equality[:text] : e.inner_text == equality[:text] }
+    end
 
-    ret = equality.keys.include?(:minimum) ? (els.size >= equality[:minimum]) : true 
-    ret &&= (els.size <= equality[:maximum]) if equality.keys.include?(:maximum)
-    ret &&= (els.size == equality[:count]) if equality.keys.include?(:count)
+    if equality.keys.include?(:html)
+      els = els.find_all {|e| equality[:html].is_a?(Regexp) ? e.inner_html =~ equality[:html] : e.inner_html.strip == equality[:html] }
+    end
+
+    n = equality.delete(:count)
+    equality[:minimum], equality[:maximum] = n, n if n
     
+    equality.merge!({:minimum => 1}) if (equality.keys & [:minimum, :maximum]).empty?
+
+    min, max = equality[:minimum], equality[:maximum]
+    message ||= %(Expected #{count_description(min, max)} matching "#{css_query}", found #{els.length}.)
+    assert els.size >= min, message if min
+    assert els.size <= max, message if max
+    if equality.keys.include?(:minimum)
+      assert(els.size >= equality[:minimum],
+	          message || "Expected at least #{equality[:minimum]} elements matching \"#{css_query}\", found #{els.size}")
+    end
+    if equality.keys.include?(:maximum)
+    	assert(els.size <= equality[:maximum],
+             message || "Expected at most #{equality[:maximum]} elements matching \"#{css_query}\", found #{els.size}")
+    end
+
+    ret = true
     if block && !els.empty?
       ret &&= self.dup.instance_eval do
         @output = HpricotTestHelper::DocumentOutput.new(els.inner_html)
         @block = true 
-        instance_eval(&block)
+        yield els
       end
     end
     
@@ -105,4 +155,21 @@
         @response_output = @response.body  
       end
     end
-end
\ No newline at end of file
+
+  private
+  def count_description(min, max) #:nodoc:
+    pluralize = lambda {|word, quantity| word << (quantity == 1 ? '' : 's')}
+          
+    if min && max
+      if (max != min)
+        "between #{min} and #{max} elements"
+      else
+        "#{min} #{pluralize['element', min]}"
+      end
+    elsif min && !(min == 1 && max == 1)
+      "at least #{min} #{pluralize['element', min]}"
+    elsif max
+      "at most #{max} #{pluralize['element', max]}"
+    end
+  end
+end
diff -rN -u old-testsuite/test/assert_elements_test.rb new-testsuite/test/assert_elements_test.rb
--- old-testsuite/test/assert_elements_test.rb	2008-10-20 23:31:06.523878423 +1100
+++ new-testsuite/test/assert_elements_test.rb	2008-10-20 23:31:06.531857422 +1100
@@ -73,7 +73,9 @@
   def test_assert_elements
     render_html %Q{<div id="1"></div><div id="2"></div>}
     assert_elements "div", 2
-    assert_failure(/Expected at least 3 elements matching \"div\", found 2/) { assert_elements "div", 3 }
+    assert_failure(/Expected 1 element matching \"div\", found 2/) { assert_elements "div", 1 }
+    assert_failure(/Expected 3 elements matching \"div\", found 2/) { assert_elements "div", 3 }
+    assert_failure(/Expected at most 1 element matching \"div\", found 2/) { assert_elements "div", :maximum => 1 }
     assert_failure(/Expected at least 1 element matching \"p\", found 0/) { assert_elements "p" }
   end
 
@@ -111,21 +113,13 @@
     assert_raises(AssertionFailedError) { assert_elements "p", html }
     assert_nothing_raised               { assert_elements "p", :html=>html }
     assert_raises(AssertionFailedError) { assert_elements "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_elements "pre", text }
-    assert_raises(AssertionFailedError) { assert_elements "pre", html }
-    assert_nothing_raised               { assert_elements "pre", :html=>html }
-    assert_raises(AssertionFailedError) { assert_elements "pre", :html=>text }
   end
 
 
   def test_counts
     render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
     assert_nothing_raised               { assert_elements "div", 2 }
-    assert_failure(/Expected at least 3 elements matching \"div\", found 2/) do
+    assert_failure(/Expected 3 elements matching \"div\", found 2/) do
       assert_elements "div", 3
     end
     assert_nothing_raised               { assert_elements "div", 1..2 }
@@ -133,7 +127,7 @@
       assert_elements "div", 3..4
     end
     assert_nothing_raised               { assert_elements "div", :count=>2 }
-    assert_failure(/Expected at least 3 elements matching \"div\", found 2/) do
+    assert_failure(/Expected 3 elements matching \"div\", found 2/) do
       assert_elements "div", :count=>3
     end
     assert_nothing_raised               { assert_elements "div", :minimum=>1 }
@@ -152,22 +146,6 @@
     end
   end
 
-
-  def test_substitution_values
-    render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
-    assert_elements "div#?", /\d+/ do |elements|
-      assert_equal 2, elements.size
-    end
-    assert_elements "div" do
-      assert_elements "div#?", /\d+/ do |elements|
-        assert_equal 2, elements.size
-        assert_elements "#1"
-        assert_elements "#2"
-      end
-    end
-  end
-
-  
   def test_nested_assert_elements
     render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
     assert_elements "div" do |elements|
@@ -225,10 +203,6 @@
 
   def test_nested_elements
     render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
-    assert_elements "div#?", /\d+/ do |elements|
-      assert_equal 1, elements(elements[0], "div").size
-      assert_equal 1, elements(elements[1], "div").size
-    end
     assert_elements "div" do
       assert_equal 2, elements("div").size
       elements("div").each do |element|