RubyGems - htree - Versions diffs - 0.7.0 - Mend

htree 0.7.0

Files changed (62) hide show

@@ -0,0 +1,17 @@
+require 'test/unit'
+require 'htree'
+class TestRawString < Test::Unit::TestCase
+  def test_elem
+    t = HTree.parse("<a>x</a>")
+    assert_equal("<a>x</a>", t.root.raw_string)
+    assert_equal("<a>x</a>", t.root.raw_string) # raw_string shouldn't have side effect.
+  end
+  def test_no_raw_string
+    t = HTree::Elem.new('a')
+    assert_equal(nil, t.raw_string)
+    t = HTree::Elem.new('a', HTree.parse("<a>x</a>").root)
+    assert_equal(nil, t.raw_string)
+  end
+end

data/test/test-rexml.rb ADDED

@@ -0,0 +1,70 @@
+require 'test/unit'
+require 'htree/parse'
+require 'htree/rexml'
+begin
+  require 'rexml/document'
+rescue LoadError
+end
+class TestREXML < Test::Unit::TestCase
+  def test_doc
+    r = HTree.parse('<root/>').to_rexml
+    assert_instance_of(REXML::Document, r)
+  end
+  def test_elem
+    r = HTree.parse('<root a="b"/>').to_rexml
+    assert_instance_of(REXML::Element, e = r.root)
+    assert_equal('root', e.name)
+    assert_equal('b', e.attribute('a').to_s)
+  end
+  def test_text
+    r = HTree.parse('<root>aaa</root>').to_rexml
+    assert_instance_of(REXML::Text, t = r.root.children[0])
+    assert_equal('aaa', t.to_s)
+  end
+  def test_xmldecl
+    s = '<?xml version="1.0"?>'
+    r = HTree.parse(s + '<root>aaa</root>').to_rexml
+    assert_instance_of(REXML::XMLDecl, x = r.children[0])
+    assert_equal('1.0', x.version)
+    assert_equal(nil, x.standalone)
+    assert_instance_of(REXML::XMLDecl, HTree.parse(s).children[0].to_rexml)
+  end
+  def test_doctype
+    s = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">'
+    r = HTree.parse(s + '<html><title>xxx</title></html>').to_rexml
+    assert_instance_of(REXML::DocType, d = r.children[0])
+    assert_equal('html', d.name)
+    assert_equal('PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"', d.external_id)
+    assert_instance_of(REXML::DocType, HTree.parse(s).children[0].to_rexml)
+  end
+  def test_procins
+    r = HTree.parse('<root><?xxx yyy?></root>').to_rexml
+    assert_instance_of(REXML::Instruction, i = r.root.children[0])
+    assert_equal('xxx', i.target)
+    assert_equal('yyy', i.content)
+    assert_instance_of(REXML::Instruction, HTree.parse('<?xxx yyy?>').children[0].to_rexml)
+  end
+  def test_comment
+    r = HTree.parse('<root><!-- zzz --></root>').to_rexml
+    assert_instance_of(REXML::Comment, c = r.root.children[0])
+    assert_equal(' zzz ', c.to_s)
+  end
+  def test_bogusetag
+    assert_equal(nil, HTree.parse('</e>').children[0].to_rexml)
+  end
+  def test_style
+    assert_equal('<style>a&lt;b</style>', HTree.parse('<html><style>a<b</style></html>').to_rexml.to_s[/<style.*style>/])
+  end
+end if defined? REXML

data/test/test-scan.rb ADDED

@@ -0,0 +1,153 @@
+require 'test/unit'
+require 'htree/scan'
+class TestScan < Test::Unit::TestCase
+  def scan(str)
+    result = []
+    HTree.scan(str) {|e| result << e }
+    result
+  end
+  def test_empty
+    assert_equal([], scan(''))
+  end
+  def t_single(s)
+    n = yield
+    assert_equal([n], scan(s))
+  end
+  def test_single
+    s = '<?xml version="1.0"?>'
+    assert_equal([[:xmldecl, s]], scan(s))
+    s = '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">'
+    assert_equal([[:doctype, s]], scan(s))
+    s = '<?xxx yyy?>'
+    assert_equal([[:procins, s]], scan(s))
+    s = '<a>'
+    assert_equal([[:stag, s]], scan(s))
+    s = '</a>'
+    assert_equal([[:etag, s]], scan(s))
+    s = '<a/>'
+    assert_equal([[:emptytag, s]], scan(s))
+    s = '<!-- abc -->'
+    assert_equal([[:comment, s]], scan(s))
+    s = '<![CDATA[abc]]>'
+    assert_equal([[:text_cdata_section, s]], scan(s))
+    s = 'abc'
+    assert_equal([[:text_pcdata, s]], scan(s))
+  end
+  def test_xmldecl_seen
+    s0 = '<?xml version="1.0"?>'
+    s1 = '<A>'
+    assert_equal([[:stag, s1]], scan(s1))
+    assert_equal([[:xmldecl, s0], [:stag, s1]], scan(s0 + s1))
+  end
+  def test_cdata_content
+    s = '<html><script><a></script><a>'
+    assert_equal([
+      [:stag, '<html>'],
+      [:stag, '<script>'],
+      [:text_cdata_content, '<a>'],
+      [:etag, '</script>'],
+      [:stag, '<a>'],
+    ], scan(s))
+    s = '<html><script><a>'
+    assert_equal([
+      [:stag, '<html>'],
+      [:stag, '<script>'],
+      [:text_cdata_content, '<a>'],
+    ], scan(s))
+  end
+  def test_text
+    s = 'a<e>b<e>c<e>d'
+    assert_equal([
+      [:text_pcdata, 'a'],
+      [:stag, '<e>'],
+      [:text_pcdata, 'b'],
+      [:stag, '<e>'],
+      [:text_pcdata, 'c'],
+      [:stag, '<e>'],
+      [:text_pcdata, 'd'],
+    ], scan(s))
+  end
+  def test_eol_html
+    # In SGML, a line break just after start tag and
+    # a line break just before end tag is ignored.
+    # http://www.w3.org/TR/REC-html40/appendix/notes.html#notes-line-breaks
+    #
+    # But usual browser including mozilla doesn't.
+    # So HTree doesn't ignore them and treat as usual text.
+    s = "<html>a\n<e>\nb\n<f>\nc\n</f>\nd\n</e>\ne"
+    assert_equal([
+      [:stag, "<html>"],
+      [:text_pcdata, "a\n"],
+      [:stag, "<e>"],
+      [:text_pcdata, "\nb\n"],
+      [:stag, "<f>"],
+      [:text_pcdata, "\nc\n"],
+      [:etag, "</f>"],
+      [:text_pcdata, "\nd\n"],
+      [:etag, "</e>"],
+      [:text_pcdata, "\ne"],
+    ], scan(s))
+    s = "<html>a\n<e>\nb\n<script>\nc\n</script>\nd\n</e>\ne"
+    assert_equal([
+      [:stag, "<html>"],
+      [:text_pcdata, "a\n"],
+      [:stag, "<e>"],
+      [:text_pcdata, "\nb\n"],
+      [:stag, "<script>"],
+      [:text_cdata_content, "\nc\n"],
+      [:etag, "</script>"],
+      [:text_pcdata, "\nd\n"],
+      [:etag, "</e>"],
+      [:text_pcdata, "\ne"],
+    ], scan(s))
+  end
+  def test_eol_xml
+    # In XML, line breaks are treated as part of content.
+    # It's because KEEPRSRE is yes in XML.
+    # http://www.satoshii.org/markup/websgml/valid-xml#keeprsre
+    s = "<?xml version='1.0'?>a\n<e>\nb\n<f>\nc\n</f>\nd\n</e>\ne"
+    assert_equal([
+      [:xmldecl, "<?xml version='1.0'?>"],
+      [:text_pcdata, "a\n"],
+      [:stag, "<e>"],
+      [:text_pcdata, "\nb\n"],
+      [:stag, "<f>"],
+      [:text_pcdata, "\nc\n"],
+      [:etag, "</f>"],
+      [:text_pcdata, "\nd\n"],
+      [:etag, "</e>"],
+      [:text_pcdata, "\ne"],
+    ], scan(s))
+  end
+  def test_xml_html_detection
+    assert_equal([false, true], HTree.scan("<html></html>") {})
+    assert_equal([true, false], HTree.scan("<rss></rss>") {})
+    assert_equal([true, true], HTree.scan('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">') {})
+  end
+  def test_quoted_attr
+    assert_equal([[:emptytag, '<e a=">"/>']], scan('<e a=">"/>'))
+  end
+  def test_bare_slash
+    assert_equal([[:stag, '<n dir=/foo/bar/>']], scan('<n dir=/foo/bar/>'))
+    assert_equal([[:stag, '<n a=v/>']], scan('<n a=v/>'))
+  end
+end

data/test/test-security.rb ADDED

@@ -0,0 +1,37 @@
+require 'test/unit'
+require 'htree/parse'
+require 'htree/template'
+require 'pathname'
+class TestSecurity < Test::Unit::TestCase
+  def safe(n)
+    assert_equal(0, $SAFE)
+    Thread.new {
+      $SAFE = n
+      assert_equal(n, $SAFE)
+      yield
+    }.join
+    assert_equal(0, $SAFE)
+  end
+  def test_parse
+    safe(1) {
+      assert_equal(1, $SAFE)
+      assert_nothing_raised { HTree.parse("") }
+      assert_raise(SecurityError) { HTree.parse("".taint) }
+    }
+    assert_nothing_raised { HTree.parse("") }
+    assert_nothing_raised { HTree.parse("".taint) }
+  end
+  def test_template
+    safe(1) {
+      assert_nothing_raised { HTree.expand_template("/dev/null", nil, '') }
+      assert_raise(SecurityError) { HTree.expand_template("/dev/null".taint, nil, '') }
+    }
+    assert_nothing_raised { HTree.expand_template("/dev/null", nil, '') }
+    assert_nothing_raised { HTree.expand_template("/dev/null".taint, nil, '') }
+  end
+end

data/test/test-subnode.rb ADDED

@@ -0,0 +1,142 @@
+require 'test/unit'
+require 'htree'
+class TestSubnode < Test::Unit::TestCase
+  def test_elem_get
+    e1 = HTree.parse("<a href=x>abc</a>").root
+    assert_equal(HTree::Text.new("x"), e1.get_subnode("href"))
+    assert_equal(HTree::Text.new("abc"), e1.get_subnode(0))
+  end
+  def test_elem_subst
+    e1 = HTree.parse_xml("<a href=x>abc</a>").root
+    e2 = e1.subst_subnode("href"=>"xxx", 0=>"def")
+    assert_equal("a", e2.name)
+    assert_equal("xxx", e2.fetch_attr("href"))
+    assert_equal([HTree::Text.new("def")], e2.children)
+    assert_equal([], e1.subst_subnode(0=>nil).children)
+  end
+  def test_elem_subst_empty
+    e1 = HTree.parse("<img />").root
+    assert_equal(true, e1.empty_element?)
+    assert_equal(true, e1.subst_subnode("src"=>"xxx").empty_element?)
+    assert_equal(false, e1.subst_subnode(0=>"xxx").empty_element?)
+  end
+  def test_elem_multiple_attr_value
+    h = {"b"=>"c", HTree::Name.new(nil, "", "b")=>"d"}
+    assert_match(/\A(cd|dc)\z/,
+      HTree::Elem.new("a").subst_subnode(h).get_subnode('b').to_s)
+    a = [["b","c"], [HTree::Name.new(nil, "", "b"),"d"]]
+    assert_equal('cd',
+      HTree::Elem.new("a").subst_subnode(a).get_subnode('b').to_s)
+    assert_equal('dc',
+      HTree::Elem.new("a").subst_subnode(a.reverse).get_subnode('b').to_s)
+  end
+  def test_elem_subst_outrange
+    e1 = HTree("<r>abc</r>").root
+    e2 = e1.subst_subnode(-1=>HTree('<x/>'), 1=>HTree('<y/>'))
+    assert_equal(HTree('<r><x/>abc<y/></r>').root, e2)
+  end
+  def test_doc_subst_outrange
+    d1 = HTree("<r>abc</r>")
+    d2 = d1.subst_subnode(-1=>HTree('<x/>'), 1=>HTree('<y/>'))
+    assert_equal(HTree('<x/><r>abc</r><y/>'), d2)
+  end
+  def test_doc_get
+    doc = HTree.parse("<?xml?><a href=x>abc</a> ")
+    assert_equal(doc.root, doc.get_subnode(1))
+  end
+  def test_doc_subst
+    doc1 = HTree.parse("<?xml?><a href=x>abc</a> ")
+    doc2 = doc1.subst_subnode(1=>"yy")
+    assert_equal(HTree::Text.new("yy"), doc2.children[1])
+    assert_equal([], doc1.subst_subnode(0=>nil, 1=>nil, 2=>nil).children)
+  end
+  def test_doc_loc
+    d1 = HTree.parse("<r>a</r>")
+    d2 = HTree.parse("<q/>")
+    assert_equal(d2, d1.subst_subnode(0=>d2.make_loc))
+  end
+  def test_doc
+    e = HTree.parse("<r>a</r>").root
+    d = HTree.parse("<?xml version='1.0'?><!DOCTYPE q><q/>")
+    r = HTree('<r><q/></r>').root
+    assert_equal(r, e.subst_subnode(0=>d))
+    assert_equal(r, e.subst_subnode(0=>d.make_loc))
+    assert_equal(r, e.subst_subnode(0=>[d]))
+    assert_equal(r, e.subst_subnode(0=>[d.make_loc]))
+  end
+  def test_doc2
+    e = HTree.parse("<r>a</r>")
+    d = HTree.parse("<?xml version='1.0'?><!DOCTYPE q><q/>")
+    r = HTree('<q/>')
+    assert_equal(r, e.subst_subnode(0=>d))
+    assert_equal(r, e.subst_subnode(0=>d.make_loc))
+    assert_equal(r, e.subst_subnode(0=>[d]))
+    assert_equal(r, e.subst_subnode(0=>[d.make_loc]))
+  end
+  def test_change_by_subst_itself
+    l = HTree("<r>a</r>").make_loc
+    l2 = l.get_subnode(0, 0).subst_itself('x')
+    assert_equal(HTree::Text.new('x'), l2.to_node)
+    assert_equal(HTree('<r>x</r>'), l2.top.to_node)
+    l2 = l.get_subnode(0).subst_itself('xxx')
+    assert_equal(HTree::Text.new('xxx'), l2.to_node)
+    assert_equal(HTree('xxx'), l2.top.to_node)
+  end
+  def test_add_by_subst_itself
+    l = HTree("<r>a</r>").make_loc
+    l2 = l.get_subnode(0, 'x').subst_itself('y')
+    assert_equal(HTree::Text.new('y'), l2.to_node)
+    assert_equal(HTree('<r x="y">a</r>'), l2.top.to_node)
+    l2 = l.get_subnode(0, 0).subst_itself('b')
+    assert_equal(HTree::Text.new('b'), l2.to_node)
+    assert_equal(HTree('<r>b</r>'), l2.top.to_node)
+    xmldecl = HTree('<?xml version="1.0"?>').get_subnode(0)
+    l2 = l.get_subnode(-1).subst_itself(xmldecl)
+    assert_equal(0, l2.index)
+    assert_equal(xmldecl, l2.to_node)
+    assert_equal(HTree('<?xml version="1.0"?><r>a</r>'), l2.top.to_node)
+    procins = HTree('<?xxx yyy?>').get_subnode(0)
+    l2 = l.get_subnode(10).subst_itself(procins)
+    assert_equal(1, l2.index)
+    assert_equal(procins, l2.to_node)
+    assert_equal(HTree('<r>a</r><?xxx yyy?>'), l2.top.to_node)
+  end
+  def test_del_by_subst_itself
+    l = HTree("<r x='y'><x/>y<z/></r>").make_loc
+    l2 = l.get_subnode(0, 'x').subst_itself(nil)
+    assert_equal(nil, l2.to_node)
+    assert_equal(HTree('<r><x/>y<z/></r>'), l2.top.to_node)
+    l2 = l.get_subnode(0, 1).subst_itself(nil)
+    assert_equal(HTree('<r x="y"><x/><z/></r>'), l2.top.to_node)
+    l = HTree('<?xml version="1.0"?><r/>').make_loc
+    l2 = l.get_subnode(0).subst_itself(nil)
+    assert_equal(HTree('<r/>'), l2.top.to_node)
+  end
+  def test_subst
+    l = HTree('<?xml version="1.0"?><r><x/><y/><z/></r>').make_loc
+    assert_equal(HTree("<r>x<y>a</y><z k=v /></r>"),
+      l.to_node.subst({
+        l.get_subnode(0) => nil,
+        l.get_subnode(1, 0) => 'x',
+        l.get_subnode(1, 1, 0) => 'a',
+        l.get_subnode(1, 2, 'k') => 'v'
+      }))
+  end
+end

data/test/test-template.rb ADDED

@@ -0,0 +1,313 @@
+require 'test/unit'
+require 'htree/template'
+require 'stringio'
+class TestTemplate < Test::Unit::TestCase
+  Decl = '<?xml version="1.0" encoding="US-ASCII"?>'
+  def assert_xhtml(expected, template, message=nil)
+    prefix = '<?xml version="1.0" encoding="US-ASCII"?>' +
+             "<html xmlns=\"http://www.w3.org/1999/xhtml\"\n>"
+    suffix = "</html\n>"
+    result = HTree.expand_template(''){"<?xml version=\"1.0\"?><html>#{template}</html>"}
+    assert_match(/\A#{Regexp.quote prefix}/, result)
+    assert_match(/#{Regexp.quote suffix}\z/, result)
+    result = result[prefix.length..(-suffix.length-1)]
+    assert_equal(expected, result, message)
+  end
+  def test_text
+    assert_xhtml("<e\n>1</e\n>", '<e _text=1>d</e>')
+    assert_xhtml('1', '<span _text=1>d</span>')
+    assert_xhtml("<span x=\"2\"\n>1</span\n>", '<span x=2 _text=1>d</span>')
+    assert_xhtml("abc", %q{a<span _text="'b'"/>c})
+  end
+  def test_tree
+    assert_xhtml("<e\n><z\n>x</z\n></e\n>", '<e _tree="HTree(&quot;<z>x</z>&quot;)">d</e>')
+    assert_xhtml("<n:e xmlns:n=\"a\"\n><n:z\n>x</n:z\n></n:e\n>", '<n:e xmlns:n=a _tree="HTree(&quot;<n:z xmlns:n=a>x</n:z>&quot;)">d</n:e>')
+  end
+  def test_attr
+    assert_xhtml("<e x=\"1\"\n>d</e\n>", '<e _attr_x=1>d</e>')
+    assert_xhtml("<span x=\"1\"\n>d</span\n>", '<span _attr_x=1>d</span>')
+    assert_xhtml("<span x=\"&quot;\"\n>d</span\n>", '<span _attr_x=\'"\x22"\'>d</span>')
+  end
+  def test_if
+    assert_xhtml("<e\n>d</e\n>", '<e _if=true>d</e>')
+    assert_xhtml('', '<e _if=false>d</e>')
+    assert_xhtml("<f\n>dd</f\n>", '<e _if=false _else=m>d</e><f _template=m>dd</f>')
+    assert_xhtml('d', '<span _if=true>d</span>')
+  end
+  def test_iter
+    assert_xhtml("<o\n><i\n>1</i\n></o\n><o\n><i\n>2</i\n></o\n><o\n><i\n>3</i\n></o\n>",
+      '<o _iter=[1,2,3].each//v><i _text=v /></o>')
+    assert_xhtml("<i\n>1</i\n><i\n>2</i\n><i\n>3</i\n>",
+      '<span _iter=[1,2,3].each//v><i _text=v /></span>')
+  end
+  def test_iter_content
+    assert_xhtml("<o\n><i\n>1</i\n><i\n>2</i\n><i\n>3</i\n></o\n>",
+      '<o _iter_content=[1,2,3].each//v><i _text=v /></o>')
+    assert_xhtml("<i\n>1</i\n><i\n>2</i\n><i\n>3</i\n>",
+      '<span _iter_content=[1,2,3].each//v><i _text=v /></span>')
+  end
+  def test_iter_local_template
+    assert_xhtml("<o\n><i\n>1</i\n></o\n><o\n><i\n>2</i\n></o\n><o\n><i\n>3</i\n></o\n>",
+      '<o _iter=[1,2,3].each//v><i _call=m /><i _template=m _text=v></i></o>')
+  end
+  def test_call
+    assert_xhtml("<f\n>1</f\n>",
+      '<e _call=m(1) /><f _template=m(v) _text=v></f>')
+  end
+  def test_template
+    assert_xhtml('d',
+      '<span _template="span()">d</span><e _call="span()"></e>')
+  end
+  def test_file
+    assert_equal(<<'End'.chop,
+<?xml version="1.0" encoding="US-ASCII"?><html xmlns="http://www.w3.org/1999/xhtml"
+><title
+>aaa</title
+></html
+>
+End
+      HTree.expand_template("#{File.dirname __FILE__}/template.html", "aaa", ''))
+  end
+  def test_whitespace
+    assert_xhtml("<x\n></x\n>", '<x> </x>')
+    assert_xhtml("<x\n>&#32;</x\n>", '<x>&#32;</x>')
+    assert_xhtml("<pre\n> </pre\n>", '<pre> </pre>')
+    assert_xhtml(" ", %q{<span _text="' '"> </span>})
+    assert_xhtml(" ", %q{<span _text="' '"/>})
+  end
+  def test_ignorable
+    assert_xhtml("<div\n>a</div\n>", '<div>a</div>')
+    assert_xhtml("<span\n>a</span\n>", '<span>a</span>')
+    assert_xhtml("1", '<span _text="1">a</span>')
+  end
+  def test_not_ignorable
+    assert_xhtml("<p\n>1</p\n>", '<p _text="\'1\'">a</p>')
+  end
+  def test_template_in_attr
+    assert_xhtml("<a x=\"1\"\n></a\n>", '<a _attr_x=1><b _template=m></b></a>')
+  end
+  def test_empty_block_argument
+    assert_xhtml("vv", '<span _iter="2.times//">v</span>')
+  end
+  def test_empty_element
+    assert_xhtml("<elem\n/>", '<elem />') # 2004-06-10: reported by Takuo KITAME
+    assert_xhtml("<elem x=\"1\"\n/>", '<elem _attr_x=1 />')
+    assert_xhtml("<elem\n></elem\n>", '<elem _text=\'""\' />')
+    assert_xhtml("<elem\n/>", '<elem _if="true" />')
+    assert_xhtml("", '<elem _if="false" />')
+    assert_xhtml("<foo\n/>", '<elem _if="false" _else="foo"/><foo _template="foo"/>')
+    assert_xhtml("<elem\n/><elem\n/>", '<elem _iter="2.times//" />')
+    assert_xhtml("<elem\n></elem\n>", '<elem _iter_content="2.times//" />')
+  end
+  def test_empty_element_start_end_tag
+    assert_xhtml("<elem\n></elem\n>", '<elem></elem>')
+    assert_xhtml("<elem x=\"1\"\n></elem\n>", '<elem _attr_x=1 ></elem>')
+    assert_xhtml("<elem\n></elem\n>", '<elem _text=\'""\' ></elem>')
+    assert_xhtml("<elem\n></elem\n>", '<elem _if="true" ></elem>')
+    assert_xhtml("", '<elem _if="false" ></elem>')
+    assert_xhtml("<foo\n></foo\n>", '<elem _if="false" _else="foo"></elem><foo _template="foo"></foo>')
+    assert_xhtml("<elem\n></elem\n><elem\n></elem\n>", '<elem _iter="2.times//" ></elem>')
+    assert_xhtml("<elem\n></elem\n>", '<elem _iter_content="2.times//" ></elem>')
+  end
+  def test_toplevel_local_variable
+    eval("htree_test_toplevel_local_variable = :non_modified_value", TOPLEVEL_BINDING)
+    HTree.expand_template("#{File.dirname __FILE__}/assign.html", "aaa", '')
+    assert_equal(:non_modified_value, eval("htree_test_toplevel_local_variable", TOPLEVEL_BINDING))
+    eval("htree_test_toplevel_local_variable = 1", TOPLEVEL_BINDING)
+  end
+  def test_extend_compiled_template
+    m = HTree.compile_template('<div _template="m">self is <span _text="inspect"></span></div>')
+    o = "zzz"
+    o.extend m
+    assert_equal('<?xml version="1.0" encoding="US-ASCII"?>self is "zzz"',
+      HTree.expand_template(''){'<div _call="o.m"></div>'})
+  end
+  def test_attr_nbsp
+    @t = HTree::Text.parse_pcdata('&nbsp;')
+    assert_xhtml("<span x=\"&nbsp;\"\n>d</span\n>", '<span _attr_x="@t">d</span>')
+  end
+  def test_text_nbsp
+    @t = HTree::Text.parse_pcdata('&nbsp;')
+    assert_xhtml("&nbsp;", '<span _text="@t">d</span>')
+  end
+  def test_content_text
+    assert_xhtml("<e\n>ab</e\n>", '<e _text>"a"+"b"</e>')
+    assert_xhtml("<e\n>2</e\n>", '<e _text>1+1</e>')
+  end
+end
+class MemFile
+  def initialize(str)
+    @str = str
+  end
+  def read
+    @str
+  end
+end
+class TestTemplateScopeObj
+  Const = 'good_const'
+  @@cvar = 'good_cvar'
+  def initialize
+    @ivar = 'good_ivar'
+  end
+end
+class TestTemplateScope < Test::Unit::TestCase
+  Const = 'bad_const'
+  @@cvar = 'bad_cvar'
+  def setup
+    @ivar = 'bad_ivar'
+    eval("test_local_variable = 'bad_lvar'", TOPLEVEL_BINDING)
+  end
+  XMLDeclStr = '<?xml version="1.0" encoding="US-ASCII"?>'
+  def test_expand_template
+    obj = TestTemplateScopeObj.new
+    assert_equal("#{XMLDeclStr}[TestTemplateScopeObj]",
+      HTree.expand_template(MemFile.new('<span _text="Module.nesting.inspect"/>'), obj, ''))
+    assert_equal("#{XMLDeclStr}good_ivar",
+      HTree.expand_template(MemFile.new('<span _text="@ivar"/>'), obj, ''))
+    assert_equal("#{XMLDeclStr}good_cvar",
+      HTree.expand_template(MemFile.new('<span _text="@@cvar"/>'), obj, ''))
+    assert_equal("#{XMLDeclStr}good_const",
+      HTree.expand_template(MemFile.new('<span _text="Const"/>'), obj, ''))
+    test_local_variable = 'bad_lvar'
+    assert_equal("#{XMLDeclStr}good_lvar",
+      HTree.expand_template(MemFile.new('<span _text="begin test_local_variable rescue NameError; \'good_lvar\' end"/>'), obj, ''))
+  end
+  def test_compile_template
+    obj = TestTemplateScopeObj.new
+    mod = HTree.compile_template(MemFile.new(<<-'End'))
+      <span _template=test_nesting _text="Module.nesting.inspect"/>
+      <span _template=test_const _text="Const"/>
+      <span _template=test_cvar _text="@@cvar"/>
+      <span _template=test_ivar _text="@ivar"/>
+    End
+    mod.module_eval <<-'End'
+      Const = 'mod_const'
+      @@cvar = 'mod_cvar'
+      @ivar = 'mod_ivar'
+    End
+    assert_equal("[#{mod.inspect}]", mod.test_nesting.extract_text.to_s)
+    assert_equal("mod_const", mod.test_const.extract_text.to_s)
+    assert_equal("mod_cvar", mod.test_cvar.extract_text.to_s)
+    assert_equal("mod_ivar", mod.test_ivar.extract_text.to_s)
+    obj = Object.new
+    obj.instance_variable_set :@ivar, 'obj_ivar'
+    obj.extend mod
+    assert_equal("[#{mod.inspect}]", obj.__send__(:test_nesting).extract_text.to_s)
+    assert_equal("mod_const", obj.__send__(:test_const).extract_text.to_s)
+    assert_equal("mod_cvar", obj.__send__(:test_cvar).extract_text.to_s)
+    assert_equal("obj_ivar", obj.__send__(:test_ivar).extract_text.to_s)
+  end
+end
+class TestCDATA < Test::Unit::TestCase
+  def test_html_script
+    v = "x<y"
+    assert_equal("<html><script>x<y</script></html>",
+      HTree.expand_template('') {"<html><script _text=\"v\">ab</script>"}.gsub(/\n/, ''))
+  end
+  def test_xml_script
+    v = "x<y"
+    assert_equal("<?xml version=\"1.0\" encoding=\"US-ASCII\"?><html xmlns=\"http://www.w3.org/1999/xhtml\"><script>x&lt;y</script></html>",
+      HTree.expand_template('') {"<?xml version=\"1.0\"?><html><script _text=\"v\">ab</script>"}.gsub(/\n/, ''))
+  end
+  def test_html_script_invalid_content
+    v = "x</y"
+    assert_raise(ArgumentError) {
+      HTree.expand_template('') {"<html><script _text=\"v\">ab</script>"}
+    }
+  end
+  def test_stylexxx
+    v = "x<y"
+    assert_equal("<html><stylexxx>x&lt;y</stylexxx></html>",
+      HTree.expand_template('') {"<html><stylexxx _text=\"v\">ab</stylexxx>"}.gsub(/\n/, ''))
+  end
+end
+class TestCharset2 < Test::Unit::TestCase
+  class CharsetString < String
+    attr_accessor :charset
+  end
+  def with_kcode(kcode)
+    if "".respond_to? :force_encoding
+      if HTree::Encoder.internal_charset.start_with?(kcode.upcase)
+        yield
+      end
+    else
+      old = $KCODE
+      begin
+        $KCODE = kcode
+        yield
+      ensure
+        $KCODE = old
+      end
+    end
+  end
+  def test_us_ascii
+    with_kcode('E') {
+      out = HTree.expand_template(CharsetString.new) { "<html>abc" }
+      assert_equal(out.charset, 'US-ASCII')
+    }
+  end
+  def test_euc_jp
+    with_kcode('E') {
+      out = HTree.expand_template(CharsetString.new) { "<html>\xa1\xa1" }
+      assert_equal(out.charset, 'EUC-JP')
+    }
+  end
+  def test_utf_8
+    with_kcode('U') {
+      out = HTree.expand_template(CharsetString.new) { "<html>\xc2\xa1" }
+      assert_equal(out.charset, 'UTF-8')
+    }
+  end
+end
+class TestTemplateDOCTYPE < Test::Unit::TestCase
+  def test_html
+    assert_equal(
+      '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"><html></html>',
+      HTree.expand_template('') {'<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"><html>'}.gsub(/\n/, ''))
+  end
+end