RubyGems - htree - Versions diffs - 0.7.0 - Mend

htree 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (62) hide show

data/test/test-raw_string.rb ADDED

@@ -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