RubyGems - htmltools - Versions diffs - 1.10 - Mend

htmltools 1.10

Files changed (20) hide show

@@ -0,0 +1,201 @@
+#!/usr/bin/ruby
+require 'html/tree'
+require 'test/unit'
+module HTMLTree
+  class Parser
+    attr_reader :currentNode
+    attr_reader :rootNode
+  end
+  module TreeElement
+    alias :ch :children
+  end
+end
+class HTMLTreeParserTestCase < Test::Unit::TestCase
+  def setup
+    @p = HTMLTree::Parser.new(true, false)
+  end
+  def rn
+    @p.rootNode
+  end
+  def cn
+    @p.currentNode
+  end
+  attr_reader :p
+  def test_empty
+    assert_equal(cn, rn)
+    assert_equal(nil, cn.parent)
+    assert_equal([], rn.children)
+  end
+  def test_skeleton
+    d = rn
+    assert_equal(d.class, HTMLTree::Document)
+    p.feed('<html></html>')
+    assert_equal(d, cn)
+    assert_equal(d, rn)
+    assert_equal(rn, @p.tree)
+    assert_equal(@p.html, @p.tree.html_node)
+    assert_equal(@p.html, rn.ch[0])
+    assert_equal(1, rn.ch.size)
+    assert_equal('', rn.tag)
+    assert_equal('html', rn.ch[0].tag)
+    assert_equal(d.html_node, rn.ch[0])
+  end
+  def test_reset
+    p.feed('<html><head></head><body attrib1="xxx"></body></html>')
+    assert_equal(1, rn.ch.size)
+    assert_equal(2, rn.ch[0].ch.size)
+    p.reset
+    assert_equal(0, rn.ch.size)
+    p.feed('<html><head></head><body attrib1="xxx"></body></html>')
+    assert_equal(1, rn.ch.size)
+    assert_equal(2, rn.ch[0].ch.size)
+  end
+  def test_skeleton2
+    d = rn
+    p.feed('<html><head></head><body attrib1="xxx"></body></html>')
+    assert_equal(d, cn)
+    assert_equal(d, rn)
+    assert_equal(1, rn.ch.size)
+    h = rn.ch[0]  # html
+    assert_equal(d.html_node, h)
+    assert_equal('html', h.tag)
+    assert_equal(2, h.ch.size)
+    assert_equal(0, h.ch[1].ch.size)
+    assert_equal(0, h.ch[0].ch.size)
+    assert_equal('head', h.ch[0].tag)
+    assert_equal('body', h.ch[1].tag)
+    assert_equal('xxx', h.ch[1].attribute('attrib1'))
+  end
+  def test_empty_tag
+    d = rn
+    p.feed('<html><head></head><body attrib1="xxx"><br></body></html>')
+    assert_equal(d, cn)
+    h = rn.ch[0]
+    assert_equal('html', h.tag)
+    assert_equal(2, h.ch.size)
+    assert_equal(0, h.ch[0].ch.size)
+    assert_equal(1, h.ch[1].ch.size)
+    assert_equal('head', h.ch[0].tag)
+    assert_equal('body', h.ch[1].tag)
+    assert_equal('br', h.ch[1].ch[0].tag)
+  end
+  def test_no_end_tag
+    p.feed("<html><body>Foo<br />bar</body></html>")
+    h = rn.ch[0]
+    assert_equal('html', h.tag)
+    assert_equal('body', h.ch[0].tag)
+    assert_equal('br', h.ch[0].ch[1].tag)
+    assert_equal({}, h.ch[0].ch[1].attributes)
+    assert_equal([], h.ch[0].ch[1].ch)
+    assert_equal('Foo', h.ch[0].ch[0].content)
+    assert_equal('bar', h.ch[0].ch[2].content)
+  end
+  def test_content
+    d = rn
+    p.feed('<html><head></head><body attrib1="xxx"><p>stuff</p></body></html>')
+    assert_equal(d, rn)
+    assert_equal(d, cn)
+    h = rn.ch[0]
+    assert_equal('html', h.tag)
+    assert_equal(2, h.ch.size) # html => head, body
+    assert_equal(0, h.ch[0].ch.size) # head =>
+    assert_equal(1, h.ch[1].ch.size) # body=>p
+    assert_equal(1, h.ch[1].ch[0].ch.size) #p=>stuff
+    assert_equal('head', h.ch[0].tag)
+    assert_equal('body', h.ch[1].tag)
+    assert_equal('p', h.ch[1].ch[0].tag)
+    data = h.ch[1].ch[0].ch[0]  # html/body/p/<data>
+    assert_equal(true, data.data?)
+    assert_equal('', data.tag)
+    assert_equal('stuff', data.to_s)
+    assert_equal({}, data.attributes)
+  end
+  def test_unclosed_li
+    p.feed('<html><body><ul><li>Item 1<li>Item 2<li>Item 3</ul></body></html>')
+    html = rn.ch[0]
+    assert_equal('html', html.tag)
+    ul = html.ch[0].ch[0]
+    assert_equal('ul', ul.tag)
+    assert_equal(3, ul.ch.size)
+  end
+  def test_partial_file
+    p.feed("<ul><li>test</li><li>test test</li></ul>")
+    li = rn.ch[0]
+    assert_equal('ul', li.tag)
+    assert_equal(2, li.ch.size)
+    assert_equal('li', li.ch[0].tag)
+    assert_equal('li', li.ch[1].tag)
+  end
+  def test_break_nesting
+    p.feed('<HTML><BODY><p><ul><LI></ul><p></BODY></HTML>')
+    expected = tree("html",
+      tree("body",  tree("p", tree("ul", tree("li"))), tree("p"))
+      )
+    expected.assert_matches(p.html)
+  end
+  def test_meta
+    p.feed('<html><head><META NAME="robots" CONTENT="noindex,follow"></head><body></body></html>')
+    expected = tree("html",
+        tree("head", tree("meta")),
+        tree("body"))
+    expected.assert_matches(p.html)
+  end
+  class VerificationTree
+    include Test::Unit::Assertions
+    def initialize(tag)
+      @tag = tag
+      @children = []
+    end
+    def add_children(children)
+      @children = children
+      self
+    end
+    def assert_matches(tree)
+      assert_equal(@tag, tree.tag)
+      assert_equal(tree.elements.collect { |node| node.tag }, @children.collect { |node| node.tag }, tree.path)
+      assert_children_matches(@children, tree.elements)
+    end
+    def assert_children_matches(children, treechildren)
+      for i in (0...children.size) do
+        children[i].assert_matches(treechildren[i])
+      end
+    end
+    attr_reader :tag
+  end
+  def tree(tag, *children)
+    tree = VerificationTree.new(tag)
+    tree.add_children(children)
+    tree
+  end
+end

data/test/tc_source-parser.rb ADDED

@@ -0,0 +1,160 @@
+# $Id: tc_source-parser.rb,v 1.3 2006/07/24 09:28:19 Philip Dorrell Exp $
+require 'html/stparser'
+require 'test/unit'
+class TestSourceParser < HTML::SGMLParser
+ def initialize(verbose, test_case)
+   super(verbose)
+   @test_case = test_case
+   @fulldata = ""
+ end
+ attr_reader :test_case
+ def feed(data)
+   @fulldata = @fulldata + data
+   super(data)
+ end
+ def last_src
+   return @fulldata[src_range]
+ end
+ def warn(msg); test_case.callback('warn', msg); end
+ def handle_starttag(tag, method, attrs); test_case.callback('starttag', last_src); end
+ def unknown_starttag(tag, attrs); test_case.callback('starttag', last_src); end
+ def handle_endtag(tag, method); test_case.callback('endtag', last_src); end
+ def unknown_endtag(tag); test_case.callback('endtag', last_src); end
+ def handle_charref(name); test_case.callback('charref', last_src); end
+ def handle_entityref(name); test_case.callback('entityref', last_src); end
+ def handle_data(data); test_case.callback('data', last_src); end
+ def handle_comment(data); test_case.callback('comment', last_src); end
+ def handle_special(data); test_case.callback('special', last_src); end
+end
+class SourceParserTestCase < Test::Unit::TestCase
+ def setup
+   @parser = TestSourceParser.new(true, self)
+   @callbacks = []
+ end
+ def callback(*stuff)
+   @callbacks << stuff
+ end
+ attr_reader :parser
+ attr_reader :callbacks
+ # run the given block and return the callbacks if any
+ def callbacks_from
+   @callbacks = []
+   yield
+   #show_callbacks
+   @callbacks
+ end
+ def show_callbacks
+   puts "Callbacks: "
+   @callbacks.each do |callback|
+     puts " [#{callback[0]}: \"#{callback[1]}\"]"
+   end
+ end
+ def test_empty_html
+   cbs = callbacks_from { parser.feed('<html>') }
+   assert_equal(1, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(['starttag', '<html>'], cbs[0])
+   cbs = callbacks_from{ parser.feed('</html>') }
+   assert_equal(1, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(['endtag', '</html>'], cbs[0])
+ end
+ def test_attribs
+   cbs = callbacks_from {
+     parser.feed('<html><body bgcolor="#ffffff" width="123"><p>Fred</p></body></html>')
+   }
+   assert_equal(7, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(['starttag', '<html>'], cbs[0])
+   assert_equal(['starttag', '<body bgcolor="#ffffff" width="123">'], cbs[1])
+   assert_equal(['data', "Fred"], cbs[3])
+   assert_equal(['endtag', '</body>'], cbs[5])
+ end
+ # FIXME should we insert <p> tags here?
+ def test_no_para_tags_in_body
+   cbs = callbacks_from { parser.feed('<html><body>Fred</body></html>') }
+   assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(['endtag', '</body>'], cbs[3])
+ end
+ def test_empty_tag
+   cbs = callbacks_from { parser.feed('<html><body><img src="whatever"></body></html>') }
+   assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(["starttag", '<img src="whatever">'], cbs[2])
+ end
+ def test_data
+   cbs = callbacks_from { parser.feed('<html><body><p>Data1</p><br><p>More_data</p></body></html>') }
+   assert_equal(11, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(["data", "Data1"], cbs[3])
+   assert_equal(["data", "More_data"], cbs[7])
+ end
+ def test_whitespace_stripping
+   cbs = callbacks_from { parser.feed('<html><body><p>  Data1  ') }
+   assert_equal(4, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(["data", "  Data1  "], cbs[3])
+   cbs = callbacks_from { parser.feed('</p><p>  Data2  </p></body></html>') }
+   assert_equal(6, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(["data", "  Data2  "], cbs[2])
+ end
+ def test_script
+   cbs = callbacks_from { parser.feed <<EOS
+<html><body>
+<script type="text/javascript" language="Java_script">
+<!--
+var page_name = "Page_view_item";
+//-->
+</script>
+</body></html>
+EOS
+   }
+   assert_equal(12, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(["starttag", '<script type="text/javascript" language="Java_script">'], cbs[3]);
+   assert_equal(["endtag", "</script>"], cbs[7])
+ end
+ def test_unknown_character
+   cbs = callbacks_from { parser.feed('<html><body>&#12345;</body></html>') }
+   assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(["charref", "&#12345;"], cbs[2])
+ end
+ def test_unknown_entity
+   cbs = callbacks_from { parser.feed('<html><body>&fred;</body></html>') }
+   assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(["entityref", "&fred;"], cbs[2])
+ end
+ def test_comment
+   cbs = callbacks_from { parser.feed('<html><body><!--  comment here --></body></html>') }
+   assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(["comment", "<!--  comment here -->"], cbs[2])
+ end
+ #TODO is this right (w/the !)?
+ def test_special
+   cbs = callbacks_from { parser.feed <<EOS
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><body></body></html>
+EOS
+   }
+   assert_equal(7, cbs.size, "cbs is #{cbs.inspect}")
+   assert_equal(["special", '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">'], cbs[0])
+ end
+end

data/test/tc_stacking-parser.rb ADDED

@@ -0,0 +1,196 @@
+# Test cases for html-tree.rb
+# Copyright (C) 2002 Ned Konz <ned@bike-nomad.com>
+# License: Ruby's
+# $Id: tc_stacking-parser.rb,v 1.4 2004/02/10 21:36:31 jhannes Exp $
+require 'html/stparser'
+require 'test/unit'
+class TestStackingParser < HTML::StackingParser
+  def initialize(verbose, test_case)
+    super(verbose)
+    @test_case = test_case
+  end
+  attr_reader :test_case
+  def warn(msg); test_case.callback('warn', msg); end
+  def handle_comment(data); super; test_case.callback('comment', data); end
+  def handle_cdata(data); test_case.callback('data', data); end
+  def handle_start_tag(tag, attrs); test_case.callback('start_tag', tag, attrs); end
+  def handle_end_tag(tag); test_case.callback('end_tag', tag); end
+  def handle_empty_tag(tag, attrs); test_case.callback('empty_tag', tag, attrs); end
+  def handle_unknown_tag(tag, attrs); test_case.callback('unknown_tag', tag, attrs); end
+  def handle_missing_end_tag(tag); test_case.callback('missing_end_tag', tag); end;
+  def handle_extra_end_tag(tag); test_case.callback('extra_end_tag', tag); end
+  def handle_script(data); test_case.callback('script', data); end
+  def handle_unknown_character(name); test_case.callback('unknown_character', name); end
+  def handle_unknown_entity(name); test_case.callback('unknown_entity', name); end
+  def handle_special(data); test_case.callback('special', data); end
+end
+class StackingParserTestCase < Test::Unit::TestCase
+  def setup
+    @parser = TestStackingParser.new(true, self)
+    @callbacks = []
+  end
+  def callback(*stuff)
+    @callbacks << stuff
+  end
+  attr_reader :parser
+  attr_reader :callbacks
+  # run the given block and return the callbacks if any
+  def callbacks_from
+    @callbacks = []
+    yield
+    @callbacks
+  end
+  def test_empty_stack
+    # test stack empty at first
+    assert(parser.stack.empty?)
+    # test last_tag and parent_tag don't blow up with empty stack
+    assert_equal('html', parser.last_tag)
+    assert_equal('html', parser.parent_tag)
+  end
+  def test_empty_html
+    cbs = callbacks_from { parser.feed('<html>') }
+    assert_same(false, parser.stack.empty?)
+    assert_equal('html', parser.last_tag)
+    assert_equal('html', parser.parent_tag)
+    assert_equal(1, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(['start_tag', 'html', []], cbs[0])
+    cbs = callbacks_from{ parser.feed('</html>') }
+    assert(parser.stack.empty?)
+    assert_equal(1, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(['end_tag', 'html'], cbs[0])
+  end
+  def test_attribs
+    cbs = callbacks_from {
+      parser.feed('<html><body bgcolor="#ffffff" width="123"><p>Fred</p></body></html>')
+    }
+    assert_same(true, parser.stack.empty?)
+    assert_equal(7, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(['start_tag', 'html', []], cbs[0])
+    assert_equal(["start_tag", "body", [["bgcolor", "#ffffff"], ["width", "123"]]], cbs[1])
+    assert_equal(['data', "Fred"], cbs[3])
+  end
+  # FIXME should we insert <p> tags here?
+  def test_no_para_tags_in_body
+    cbs = callbacks_from { parser.feed('<html><body>Fred</body></html>') }
+    assert_equal(true, parser.stack.empty?)
+    assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(['data', 'Fred'], cbs[2])
+  end
+  def test_empty_tag
+    cbs = callbacks_from { parser.feed('<html><body><img src="whatever"></body></html>') }
+    assert_equal(true, parser.stack.empty?)
+    assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["empty_tag", "img", [["src", "whatever"]]], cbs[2])
+  end
+  def test_unknown_tag
+    cbs = callbacks_from { parser.feed('<html><body><froobzle a="b"></froobzle></body></html>') }
+    assert_equal(true, parser.stack.empty?)
+    assert_equal(6, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["unknown_tag", "froobzle", [["a", "b"]]], cbs[2])
+  end
+  def test_missing_end_tag
+    cbs = callbacks_from { parser.feed('<html><body><div></body></html>') }
+    assert_equal(true, parser.stack.empty?)
+    assert_equal(6, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["missing_end_tag", "div"], cbs[3])
+  end
+  def test_extra_end_tag
+    cbs = callbacks_from { parser.feed('<html><body></body></body></html>') }
+    assert_equal(true, parser.stack.empty?)
+    assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["extra_end_tag", "body"], cbs[3])
+  end
+  def test_data
+    cbs = callbacks_from { parser.feed('<html><body><p>Data1</p><br><p>More_data</p></body></html>') }
+    assert_equal(true, parser.stack.empty?)
+    assert_equal(11, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["data", "Data1"], cbs[3])
+    assert_equal(["data", "More_data"], cbs[7])
+  end
+  def test_whitespace_stripping
+    parser.strip_whitespace = false
+    cbs = callbacks_from { parser.feed('<html><body><p>  Data1  ') }
+    assert_equal(4, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["data", "  Data1  "], cbs[3])
+    parser.strip_whitespace = true
+    cbs = callbacks_from { parser.feed('</p><p>  Data2  </p></body></html>') }
+    assert_equal(6, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["data", "Data2"], cbs[2])
+    assert_equal(true, parser.stack.empty?)
+  end
+  def test_script
+    parser.strip_whitespace = true
+    cbs = callbacks_from { parser.feed <<EOS
+<html><body>
+<script type="text/javascript" language="Java_script">
+<!--
+var page_name = "Page_view_item";
+//-->
+</script>
+</body></html>
+EOS
+    }
+    assert_equal([], parser.stack)
+    assert_equal(true, parser.stack.empty?)
+    assert_equal(7, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["start_tag", "script",
+      [["type", "text/javascript"], ["language", "Java_script"]]], cbs[2])
+    assert_equal(["script", "\n<!--\nvar page_name = \"Page_view_item\";\n//-->\n"], cbs[3])
+    assert_equal(["end_tag", "script"], cbs[4])
+  end
+  def test_unknown_character
+    cbs = callbacks_from { parser.feed('<html><body>&#12345;</body></html>') }
+    assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["unknown_character", "12345"], cbs[2])
+  end
+  def test_unknown_entity
+    cbs = callbacks_from { parser.feed('<html><body>&fred;</body></html>') }
+    assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["unknown_entity", "fred"], cbs[2])
+  end
+  def test_comment
+    parser.strip_whitespace = true
+    cbs = callbacks_from { parser.feed('<html><body><!--  comment here --></body></html>') }
+    assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["comment", "comment here"], cbs[2])
+  end
+  #TODO is this right (w/the !)?
+  def test_special
+    parser.strip_whitespace = true
+    cbs = callbacks_from { parser.feed <<EOS
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html><body></body></html>
+EOS
+    }
+    assert_equal(5, cbs.size, "cbs is #{cbs.inspect}")
+    assert_equal(["special", '!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"'], cbs[0])
+  end
+end
+$stdout.sync = true