htree 0.7.0

data/test/test-extract_text.rb

@@ -0,0 +1,18 @@
+require 'test/unit'
+require 'htree/extract_text'
+require 'htree/equality'
+
+class TestExtractText < Test::Unit::TestCase
+  def test_single
+    n = HTree::Text.new('abc')
+    assert_equal(n, n.extract_text)
+  end
+
+  def test_elem
+    t = HTree::Text.new('abc')
+    n = HTree::Elem.new('e', t)
+    assert_equal(t, n.extract_text)
+  end
+
+
+end

data/test/test-gencode.rb

@@ -0,0 +1,27 @@
+require 'test/unit'
+require 'htree/gencode'
+require 'htree/parse'
+
+class TestGenCode < Test::Unit::TestCase
+  def run_code(code, top_context)
+    out = HTree::Encoder.new(HTree::Encoder.internal_charset, HTree::Encoder.internal_charset)
+    eval(code)
+    out.finish
+  end
+
+  def test_xmlns
+    t = HTree.parse_xml('<p:n xmlns:p=z><p:m>bb').children[0].children[0] # <p:m>bb</p:m>
+    code = t.generate_xml_output_code
+    
+    assert_equal("<p:m xmlns:p=\"z\"\n>bb</p:m\n>", run_code(code, HTree::DefaultContext))
+    assert_equal("<p:m\n>bb</p:m\n>", run_code(code, HTree::DefaultContext.subst_namespaces("p"=>"z")))
+  end
+
+  def test_xmlns_chref
+    t = HTree.parse_xml('<p:n xmlns:p="a&amp;<>&quot;b"/>').children[0]
+    code = t.generate_xml_output_code
+    assert_equal("<p:n xmlns:p=\"a&amp;&lt;&gt;&quot;b\"\n/>", run_code(code, HTree::DefaultContext))
+  end
+
+end
+

data/test/test-leaf.rb

@@ -0,0 +1,25 @@
+require 'test/unit'
+require 'htree/leaf'
+
+class TestProcIns < Test::Unit::TestCase
+  def test_initialize
+    assert_raises(HTree::ProcIns::Error) { HTree::ProcIns.new!('target', "?>") }
+  end
+
+  def test_new
+    assert_equal('? >', HTree::ProcIns.new('target', "?>").content)
+    assert_equal(nil, HTree::ProcIns.new('target', nil).content)
+  end
+end
+
+class TestComment < Test::Unit::TestCase
+  def test_initialize
+    assert_raises(HTree::Comment::Error) { HTree::Comment.new!("a--b") }
+    assert_raises(HTree::Comment::Error) { HTree::Comment.new!("a-") }
+  end
+
+  def test_new
+    assert_equal('a- -b', HTree::Comment.new("a--b").content)
+    assert_equal('a- ', HTree::Comment.new("a-").content)
+  end
+end

data/test/test-loc.rb

@@ -0,0 +1,60 @@
+require 'test/unit'
+require 'htree/loc'
+require 'htree/parse'
+require 'htree/traverse'
+
+class TestLoc < Test::Unit::TestCase
+  def test_make_loc
+    t = HTree.parse('<?xml version="1.0"?><!DOCTYPE root><root>a<?x y?><!-- c --></boo>')
+    assert_instance_of(HTree::Doc::Loc, t.make_loc)
+    assert_instance_of(HTree::XMLDecl::Loc, t.children[0].make_loc)
+    assert_instance_of(HTree::DocType::Loc, t.children[1].make_loc)
+    assert_instance_of(HTree::Elem::Loc, t.children[2].make_loc)
+    assert_instance_of(HTree::Text::Loc, t.children[2].children[0].make_loc)
+    assert_instance_of(HTree::ProcIns::Loc, t.children[2].children[1].make_loc)
+    assert_instance_of(HTree::Comment::Loc, t.children[2].children[2].make_loc)
+    assert_instance_of(HTree::BogusETag::Loc, t.children[2].children[3].make_loc)
+    assert_equal(nil, t.make_loc.parent)
+    assert_equal(nil, t.make_loc.index)
+  end
+
+  def test_get_subnode
+    t = HTree.parse('<?xml version="1.0"?><!DOCTYPE root><root>a<?x y?><!-- c --></boo>')
+    l = t.make_loc
+    assert_instance_of(HTree::Doc::Loc, l)
+    assert_instance_of(HTree::Location, l.get_subnode(-1))
+    assert_instance_of(HTree::XMLDecl::Loc, l.get_subnode(0))
+    assert_instance_of(HTree::DocType::Loc, l.get_subnode(1))
+    assert_instance_of(HTree::Elem::Loc, l2 = l.get_subnode(2))
+    assert_instance_of(HTree::Location, l.get_subnode(3))
+    assert_instance_of(HTree::Location, l2.get_subnode(-1))
+    assert_instance_of(HTree::Location, l2.get_subnode('attr'))
+    assert_instance_of(HTree::Text::Loc, l2.get_subnode(0))
+    assert_instance_of(HTree::ProcIns::Loc, l2.get_subnode(1))
+    assert_instance_of(HTree::Comment::Loc, l2.get_subnode(2))
+    assert_instance_of(HTree::BogusETag::Loc, l2.get_subnode(3))
+    assert_instance_of(HTree::Location, l2.get_subnode(4))
+    assert_same(l.get_subnode(0), l.get_subnode(0))
+  end
+
+  def test_find_loc_step
+    t = HTree.parse('<a><b>x<!---->y</a><c/><a/>')
+    assert_equal('a[1]', t.find_loc_step(0))
+    assert_equal('c', t.find_loc_step(1))
+    assert_equal('a[2]', t.find_loc_step(2))
+    t = t.children[0]
+    assert_equal('b', t.find_loc_step(0))
+    t = t.children[0]
+    assert_equal('text()[1]', t.find_loc_step(0))
+    assert_equal('comment()', t.find_loc_step(1))
+    assert_equal('text()[2]', t.find_loc_step(2))
+  end
+
+  def test_path
+    l = HTree.parse('<a><b>x</b><b/><a/>').make_loc
+    l2 = l.get_subnode(0, 0, 0)
+    assert_equal('doc()', l.path)
+    assert_equal('doc()/a/b[1]/text()', l2.path)
+  end
+
+end

data/test/test-namespace.rb

@@ -0,0 +1,147 @@
+require 'test/unit'
+require 'htree/tag'
+
+class TestNamespace < Test::Unit::TestCase
+  def assert_equal_exact(expected, actual, message=nil)
+    full_message = build_message(message, <<EOT, expected, actual)
+<?> expected but was
+<?>.
+EOT
+    assert_block(full_message) { expected.equal_exact? actual }
+  end
+
+  # <ppp:nnn xmlns:ppp="uuu">
+  def test_prefixed
+    stag = HTree::STag.new("ppp:nnn",
+      [["xmlns:ppp", "uuu"], ["a", "x"], ["q:b", "y"], ["pp{uu}c", "z"]],
+      HTree::DefaultContext.subst_namespaces({"q"=>"u"}))
+    assert_equal("ppp:nnn", stag.element_name.qualified_name)
+    assert_equal("{uuu}nnn", stag.element_name.universal_name)
+    assert_equal("nnn", stag.element_name.local_name)
+    assert_equal("uuu", stag.element_name.namespace_uri)
+    assert_equal("ppp", stag.element_name.namespace_prefix)
+
+    nsattrs = []; stag.each_namespace_attribute {|p, u| nsattrs << [p, u] }
+    assert_equal(1, nsattrs.length)
+    assert_equal(["ppp", "uuu"], nsattrs.shift)
+
+    attrs = []; stag.each_attribute {|n,t| attrs << [n.namespace_uri,n.namespace_prefix,n.local_name,t.to_s] }
+    assert_equal(3, attrs.length)
+    assert_equal(['', nil, "a", "x"], attrs.shift)
+    assert_equal(["u", "q", "b", "y"], attrs.shift)
+    assert_equal(["uu", "pp", "c", "z"], attrs.shift)
+  end
+
+  # <nnn xmlns="uuu">
+  def test_default_ns
+    stag = HTree::STag.new("nnn",
+      [["xmlns", "uuu"],
+      ["a", "x"], ["q:b", "y"], ["pp{uu}c", "z"]],
+      HTree::DefaultContext.subst_namespaces({"q"=>"u"}))
+
+    assert_equal("nnn", stag.element_name.qualified_name)
+    assert_equal("{uuu}nnn", stag.element_name.universal_name)
+    assert_equal("nnn", stag.element_name.local_name)
+    assert_equal("uuu", stag.element_name.namespace_uri)
+    assert_equal(nil, stag.element_name.namespace_prefix)
+
+    nsattrs = []; stag.each_namespace_attribute {|p, u| nsattrs << [p, u] }
+    assert_equal(1, nsattrs.length)
+    assert_equal([nil, "uuu"], nsattrs.shift)
+
+    attrs = []; stag.each_attribute {|n,t| attrs << [n.namespace_uri,n.namespace_prefix,n.local_name,t.to_s] }
+    assert_equal(3, attrs.length)
+    assert_equal(['', nil, "a", "x"], attrs.shift)
+    assert_equal(["u", "q", "b", "y"], attrs.shift)
+    assert_equal(["uu", "pp", "c", "z"], attrs.shift)
+  end
+
+  # <nnn xmlns="">
+  def test_no_default_ns
+    [{"q"=>"u"}, {nil=>"uu", "q"=>"u"}].each {|inh|
+      stag = HTree::STag.new("nnn",
+        [["xmlns", ""], ["a", "x"], ["q:b", "y"], ["pp{uu}c", "z"]],
+        HTree::DefaultContext.subst_namespaces(inh))
+      assert_equal("nnn", stag.element_name.qualified_name)
+      assert_equal("nnn", stag.element_name.universal_name)
+      assert_equal("nnn", stag.element_name.local_name)
+      assert_equal('', stag.element_name.namespace_uri)
+      assert_equal(nil, stag.element_name.namespace_prefix)
+
+      nsattrs = []; stag.each_namespace_attribute {|p, u| nsattrs << [p, u] }
+      assert_equal(1, nsattrs.length)
+      assert_equal([nil, ""], nsattrs.shift)
+
+      attrs = []; stag.each_attribute {|n,t| attrs << [n.namespace_uri,n.namespace_prefix,n.local_name,t.to_s] }
+      assert_equal(3, attrs.length)
+      assert_equal(['', nil, "a", "x"], attrs.shift)
+      assert_equal(["u", "q", "b", "y"], attrs.shift)
+      assert_equal(["uu", "pp", "c", "z"], attrs.shift)
+    }
+  end
+
+  # <nnn>
+  def test_no_ns
+    stag = HTree::STag.new("nnn",
+      [["a", "x"], ["q:b", "y"], ["pp{uu}c", "z"]],
+      HTree::DefaultContext.subst_namespaces({"q"=>"u"}))
+
+    assert_equal("nnn", stag.element_name.qualified_name)
+    assert_equal("nnn", stag.element_name.universal_name)
+    assert_equal("nnn", stag.element_name.local_name)
+    assert_equal('', stag.element_name.namespace_uri)
+    assert_equal(nil, stag.element_name.namespace_prefix)
+
+    nsattrs = []; stag.each_namespace_attribute {|p, u| nsattrs << [p, u] }
+    assert_equal(0, nsattrs.length)
+
+    attrs = []; stag.each_attribute {|n,t| attrs << [n.namespace_uri,n.namespace_prefix,n.local_name,t.to_s] }
+    assert_equal(3, attrs.length)
+    assert_equal(['', nil, "a", "x"], attrs.shift)
+    assert_equal(["u", "q", "b", "y"], attrs.shift)
+    assert_equal(["uu", "pp", "c", "z"], attrs.shift)
+  end
+
+  # internally allocated element without prefix
+  def test_universal_name_to_be_default_namespace
+    stag = HTree::STag.new("{uuu}nnn",
+      [["a", "x"], ["q:b", "y"], ["pp{uu}c", "z"]],
+      HTree::DefaultContext.subst_namespaces({"q"=>"u"}))
+    assert_equal("nnn", stag.element_name.qualified_name)
+    assert_equal("{uuu}nnn", stag.element_name.universal_name)
+    assert_equal("nnn", stag.element_name.local_name)
+    assert_equal("uuu", stag.element_name.namespace_uri)
+    assert_equal(nil, stag.element_name.namespace_prefix)
+
+    nsattrs = []; stag.each_namespace_attribute {|p, u| nsattrs << [p, u] }
+    assert_equal(0, nsattrs.length)
+
+    attrs = []; stag.each_attribute {|n,t| attrs << [n.namespace_uri,n.namespace_prefix,n.local_name,t.to_s] }
+    assert_equal(3, attrs.length)
+    assert_equal(['', nil, "a", "x"], attrs.shift)
+    assert_equal(["u", "q", "b", "y"], attrs.shift)
+    assert_equal(["uu", "pp", "c", "z"], attrs.shift)
+  end
+
+  def test_prefixed_universal_name
+    stag = HTree::STag.new("ppp{uuu}nnn",
+      [["a", "x"], ["q:b", "y"], ["pp{uu}c", "z"], ["q{uu}d", "w"]],
+      HTree::DefaultContext.subst_namespaces({"q"=>"u"}))
+    assert_equal("ppp:nnn", stag.element_name.qualified_name)
+    assert_equal("{uuu}nnn", stag.element_name.universal_name)
+    assert_equal("nnn", stag.element_name.local_name)
+    assert_equal("uuu", stag.element_name.namespace_uri)
+    assert_equal("ppp", stag.element_name.namespace_prefix)
+
+    nsattrs = []; stag.each_namespace_attribute {|p, u| nsattrs << [p, u] }
+    assert_equal(0, nsattrs.length)
+
+    attrs = []; stag.each_attribute {|n,t| attrs << [n.namespace_uri,n.namespace_prefix,n.local_name,t.to_s] }
+    assert_equal(4, attrs.length)
+    assert_equal(['', nil, "a", "x"], attrs.shift)
+    assert_equal(["u", "q", "b", "y"], attrs.shift)
+    assert_equal(["uu", "pp", "c", "z"], attrs.shift)
+    assert_equal(["uu", "q", "d", "w"], attrs.shift)
+  end
+
+end

data/test/test-output.rb

@@ -0,0 +1,133 @@
+require 'test/unit'
+require 'htree'
+
+class TestOutput < Test::Unit::TestCase
+  def gen(t, meth=:output, *rest)
+    encoder = HTree::Encoder.new('US-ASCII', 'US-ASCII')
+    t.__send__(meth, *(rest + [encoder, HTree::DefaultContext]))
+    encoder.finish
+  end
+
+  def test_text
+    assert_equal('a&amp;&lt;&gt;"b', gen(HTree::Text.new('a&<>"b')))
+
+    assert_equal("abc&amp;def", gen(HTree::Text.new("abc&def")))
+    assert_equal('"\'&amp;', gen(HTree::Text.new('"\'&')))
+    assert_equal('"\'&lt;&amp;&gt;', gen(HTree::Text.new('"\'<&>')))
+  end
+
+  def test_text_attvalue
+    assert_equal('"a&amp;&lt;&gt;&quot;b"', gen(HTree::Text.new('a&<>"b'), :output_attvalue))
+
+    assert_equal('"abc"', gen(HTree::Text.new("abc"), :output_attvalue))
+    assert_equal('"&quot;"', gen(HTree::Text.new('"'), :output_attvalue))
+  end
+
+  def test_name
+    assert_equal('abc', gen(HTree::Name.parse_element_name('abc', HTree::DefaultContext)))
+    assert_equal('n', gen(HTree::Name.new(nil, 'u', 'n')))
+    assert_equal('p:n', gen(HTree::Name.new('p', 'u', 'n')))
+    assert_equal('n', gen(HTree::Name.new(nil, '', 'n')))
+    assert_equal('xmlns', gen(HTree::Name.new('xmlns', nil, nil)))
+    assert_equal('xmlns:n', gen(HTree::Name.new('xmlns', nil, 'n')))
+  end
+
+  def test_name_attribute
+    assert_equal('abc="a&amp;&lt;&gt;&quot;b"',
+      gen(HTree::Name.parse_element_name('abc', HTree::DefaultContext),
+          :output_attribute,
+          HTree::Text.new('a&<>"b')))
+  end
+
+  def test_doc
+    t = HTree::Doc.new(HTree::Elem.new('a'), HTree::Elem.new('b'))
+    assert_equal("<a\n/><b\n/>", gen(t))
+  end
+
+  def test_elem
+    t = HTree::Elem.new('a', [])
+    assert_equal("<a\n></a\n>", gen(t))
+
+    assert_equal("<b\n/>",
+      gen(HTree::Elem.new!(HTree::STag.new('b'))))
+    assert_equal("<b\n></b\n>",
+      gen(HTree::Elem.new!(HTree::STag.new('b'), [])))
+    assert_equal("<a\n><b\n/><c\n/><d\n/></a\n>",
+      gen(HTree::Elem.new!(HTree::STag.new('a'), [
+            HTree::Elem.new!(HTree::STag.new('b')),
+            HTree::Elem.new!(HTree::STag.new('c')),
+            HTree::Elem.new!(HTree::STag.new('d'))
+            ])))
+  end
+
+  def test_elem_empty
+    t = HTree::Elem.new('a')
+    assert_equal("<a\n/>", gen(t))
+  end
+
+  def test_stag
+    assert_equal("<name\n>",
+      gen(HTree::STag.new("name"), :output_stag))
+    assert_equal("<name\n/>",
+      gen(HTree::STag.new("name"), :output_emptytag))
+    assert_equal("</name\n>",
+      gen(HTree::STag.new("name"), :output_etag))
+      
+    assert_equal("<name a=\"b\"\n/>",
+      gen(HTree::STag.new("name", [["a", "b"]]), :output_emptytag))
+    assert_equal("<name a=\"&lt;&quot;\'&gt;\"\n/>",
+      gen(HTree::STag.new("name", [['a', '<"\'>']]), :output_emptytag))
+      
+    assert_equal("<ppp:nnn xmlns=\"uuu&quot;b\"\n/>",
+      gen(HTree::STag.new("ppp:nnn", [["xmlns", "uuu\"b"]]), :output_emptytag))
+  end
+
+  def test_xmldecl
+    t = HTree::XMLDecl.new('1.0', 'US-ASCII')
+    assert_equal('', gen(t))
+    assert_equal('<?xml version="1.0" encoding="US-ASCII"?>',
+      gen(t, :output_prolog_xmldecl))
+  end
+
+  def test_doctype
+    t = HTree::DocType.new('html',
+      '-//W3C//DTD HTML 4.01//EN',
+      'http://www.w3.org/TR/html4/strict.dtd')
+    assert_equal('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">', gen(t))
+  end
+
+  def test_procins
+    t = HTree::ProcIns.new('xml-stylesheet', 'type="text/xml" href="#style1"')
+    assert_equal('<?xml-stylesheet type="text/xml" href="#style1"?>', gen(t))
+    t = HTree::ProcIns.new('x', nil)
+    assert_equal('<?x?>', gen(t))
+  end
+
+  def test_comment
+    t = HTree::Comment.new('xxx')
+    assert_equal('<!--xxx-->', gen(t))
+  end
+
+end
+
+class TestHTMLOutput < Test::Unit::TestCase
+  def test_top_xmlns
+    assert_equal("<html\n>aaa</html\n>", HTree("<html>aaa").display_html(""))
+  end
+
+  def test_script
+    assert_equal("<html\n><script\n>a < b</script\n></html\n>",
+      HTree("<html><script>a < b").display_html(""))
+  end
+
+  def test_script_invalid_content
+    assert_raise(ArgumentError) {
+      HTree("<html><script>a </ b").display_html("")
+    }
+  end
+
+  def test_br
+    assert_equal("<html\n>a<br\n>b<br\n>c</html\n>",
+      HTree("<html>a<br>b<br>c").display_html(""))
+  end
+end

data/test/test-parse.rb

@@ -0,0 +1,115 @@
+require 'test/unit'
+require 'htree/parse'
+require 'htree/equality'
+require 'htree/traverse'
+
+class TestParse < Test::Unit::TestCase
+  def test_empty
+    assert_equal(HTree::Doc.new([]), HTree.parse_xml("").eliminate_raw_string)
+  end
+
+  def test_xmlns_default
+    t1 = HTree::Doc.new([
+           HTree::Elem.new!(
+             HTree::STag.new('x1', [['xmlns', 'bb']],
+               HTree::DefaultContext.subst_namespaces({'xml'=>'http://www.w3.org/XML/1998/namespace'})),
+             [HTree::Elem.new!(HTree::STag.new('x2', [],
+                                HTree::DefaultContext.subst_namespaces({nil => 'bb', 'xml'=>'http://www.w3.org/XML/1998/namespace'})), nil)])
+         ])
+    t2 = HTree.parse_xml('<x1 xmlns="bb"><x2>')
+    assert_equal(t1, t2)
+  end
+
+  def test_doctype_root_element_name
+    assert_equal('html',
+      HTree.parse('<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"><html>').children[0].root_element_name)
+
+    # xxx: should be downcased?
+    assert_equal('HTML',
+      HTree.parse('<?xml version="1.0"?><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"><HTML>').children[1].root_element_name)
+  end
+
+  def test_doctype_system_identifier
+    assert_equal('http://www.w3.org/TR/html4/loose.dtd',
+      HTree.parse("<!DOCTYPE HTML SYSTEM 'http://www.w3.org/TR/html4/loose.dtd'>").children[0].system_identifier)
+    assert_equal('http://www.w3.org/TR/html4/loose.dtd',
+      HTree.parse("<!DOCTYPE HTML PUBLIC '-//W3C//DTD HTML 4.01 Transitional//EN' 'http://www.w3.org/TR/html4/loose.dtd'>").children[0].system_identifier)
+  end
+
+  def test_procins
+    t = HTree.parse_xml("<?x?>").children[0]
+    assert_equal('x', t.target)
+    assert_equal(nil, t.content)
+  end
+
+  def test_eol_html
+    t1 = HTree::Elem.new('a', "\nb\n")
+    s = "<a>\nb\n</a>"
+    t2 = HTree.parse_xml(s).root
+    assert_equal(t1, t2)
+    assert_equal(s, t2.raw_string)
+  end
+
+  def test_parse_html
+    t1 = HTree.parse("<html>a</html>")
+    assert_equal("{http://www.w3.org/1999/xhtml}html", t1.root.element_name.universal_name)
+  end
+
+  def test_bare_url
+    t1 = HTree::Elem.new('a', {'href'=>'http://host/'})
+    s = "<a href=http://host/>"
+    t2 = HTree.parse(s).root
+    assert_equal(t1, t2)
+  end
+
+  def test_bare_slash
+    t1 = HTree::Elem.new('n', {'a'=>'v/'}, 'x')
+    s = "<n a=v/>x"
+    t2 = HTree.parse(s).root
+    assert_equal(t1, t2)
+  end
+
+  def test_bare_slash_empty
+    t1 = HTree::Elem.new('n', {'a'=>'v/'})
+    s = "<n a=v/>"
+    t2 = HTree.parse(s).root
+    assert_equal(t1, t2)
+  end
+
+  def test_downcase
+    assert_equal("{http://www.w3.org/1999/02/22-rdf-syntax-ns#}RDF",
+      HTree.parse('<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"/>').root.name)
+  end
+
+  def test_downcase_name
+    # HTML && !XML
+    assert_equal('html', HTree.parse('<HTML>').root.element_name.local_name)
+    assert_equal('html', HTree.parse('<html>').root.element_name.local_name)
+    # HTML && XML
+    assert_equal('html', HTree.parse('<?xml version="1.0"?><html>').root.element_name.local_name)
+    assert_equal('v', HTree.parse('<?xml version="1.0"?><html X:Y=v xmlns:X=u>').root.get_attr('{u}Y'))
+    # !HTML && XML
+    assert_equal('RDF', HTree.parse('<?xml version="1.0"?><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"/>').children[1].element_name.local_name)
+  end
+
+  def test_script_etag
+    assert_equal(HTree::Doc.new(HTree::Elem.new('{http://www.w3.org/1999/xhtml}script', [])),
+      HTree.parse('<script></script>'))
+  end
+
+  def test_html_emptyelem
+    t = HTree.parse('<html>')
+    assert_equal(HTree::Doc.new(HTree::Elem.new('{http://www.w3.org/1999/xhtml}html')), t)
+    assert(!t.children[0].empty_element?)
+  end
+
+  def test_hr_emptyelem
+    t = HTree.parse('<html><hr>')
+    assert_equal(
+      HTree::Doc.new(
+        HTree::Elem.new('{http://www.w3.org/1999/xhtml}html',
+          HTree::Elem.new('{http://www.w3.org/1999/xhtml}hr'))), t)
+    assert(t.children[0].children[0].empty_element?)
+  end
+
+end