tdiary 3.2.2.20130518 → 3.2.2.20130527

data/vendor/rdtool-0.6.38/test/test-nonterminal-inline.rb

@@ -1,33 +0,0 @@
-require 'test/unit'
-
-require 'rd/inline-element'
-require 'rd/document-struct'
-require 'dummy'
-
-include RD
-
-DummyStruct.define_relationship(NonterminalInline, DummyElement)
-
-class TestNonterminalInline < Test::Unit::TestCase
-  def test_children
-    el = NonterminalInline.new
-    assert_equal([], el.children)
-    el.children.push 1
-    assert_equal([1], el.children)
-  end
-
-  def test_to_label
-    one = NonterminalInline.new
-    one.add_child_under_document_struct(DummyElement.new, DummyStruct)
-    assert_equal("label", one.to_label)
-
-    two = NonterminalInline.new
-    two.add_child_under_document_struct(DummyElement.new, DummyStruct)
-    two.add_child_under_document_struct(DummyElement.new, DummyStruct)
-    assert_equal("label  label", two.to_label)
-
-    zero = NonterminalInline.new
-    assert_equal("", zero.to_label)
-  end
-end
-

data/vendor/rdtool-0.6.38/test/test-output-format-visitor.rb

@@ -1,48 +0,0 @@
-require 'test/unit'
-
-require 'temp-dir'
-
-require 'rd/output-format-visitor'
-require 'rd/tree'
-require 'rd/element'
-require 'rd/block-element'
-require 'rd/inline-element'
-require 'rd/rd-struct'
-
-include RD
-
-class TestOFVisitor < Test::Unit::TestCase
-  def setup
-  end
-
-  def test_initialize
-    vis = OutputFormatVisitor.new
-    assert_equal([], vis.include_suffix)
-    vis = SampleVisitor.new
-    assert_equal(["html"], vis.include_suffix)    
-  end
-
-  def test_apply_to_include
-    tree = Tree.new_with_document_struct(DocumentStructure::RD,
-                                         ["test/data/sub", "test/data/"])
-    de = DocumentElement.new
-    # test/data/includee1.html
-    inc1 = Include.new("includee1")
-    # test/data/includee2.html, test/data/sub/includee2.html
-    inc2 = Include.new("includee2")
-    # test/data/includee3.nothtml
-    inc3 = Include.new("includee3")
-    tree.root = de
-    de.add_child(inc1)
-    de.add_child(inc2)
-    de.add_child(inc3)
-    vis = SampleVisitor.new
-    assert_equal("includee1.html", vis.apply_to_Include(inc1))
-    assert_equal("sub/includee2.html", vis.apply_to_Include(inc2))
-    assert_equal(nil, vis.apply_to_Include(inc3))
-  end
-end
-
-class SampleVisitor < OutputFormatVisitor
-  INCLUDE_SUFFIX = ["html"]
-end

data/vendor/rdtool-0.6.38/test/test-parser-util.rb

@@ -1,41 +0,0 @@
-require 'test/unit'
-
-require 'rd/rdblockparser.tab'
-require 'rd/rd-struct'
-
-include RD
-
-class TestParserUtil < Test::Unit::TestCase
-  def setup
-    @p = RDParser.new
-    @tree = tree = Tree.new_with_document_struct(DocumentStructure::RD)
-    @p.instance_eval do
-      @tree = tree
-    end
-  end
-
-  def test_tree
-    obj = Object.new
-    obj.extend(ParserUtility)
-
-    assert_raises(NotImplementedError) do
-      obj.tree
-    end
-  end
-
-  def test_add_children_to_element
-    headline = Headline.new(1)
-    string_element = StringElement.new "string"
-    emphasis = Emphasis.new
-    @p.add_children_to_element(headline, string_element, emphasis)
-    assert_equal([string_element, emphasis], headline.children)
-
-    textblock = TextBlock.new
-    @p.add_children_to_element(textblock, emphasis, string_element)
-    assert_equal([emphasis, string_element], textblock.children)
-
-    textblock_empty = TextBlock.new
-    @p.add_children_to_element(textblock_empty)
-    assert_equal([], textblock_empty.children)
-  end
-end

data/vendor/rdtool-0.6.38/test/test-rbl-file.rb

@@ -1,156 +0,0 @@
-require 'test/unit'
-
-require 'temp-dir'
-
-require 'rd/rbl-file'
-require 'rd/block-element'
-require 'rd/inline-element'
-require 'rd/rd-struct'
-require 'rd/reference-resolver'
-
-include RD
-
-class TestRBLFile < Test::Unit::TestCase
-  
-  def setup
-    tr_head2 = Tree.new_with_document_struct(DocumentStructure::RD)
-    de_head2 = DocumentElement.new
-    tr_head2.root = de_head2
-    hl1_head2, hl2_head2 = nil
-
-    de_head2.build do
-      hl1_head2 = new Headline, 1 do
-        new StringElement, "label1"
-      end
-      new TextBlock
-      hl2_head2 = new Headline, 2 do
-        new StringElement, "label2"
-      end
-    end
-
-    @resolv_head2 = ReferenceResolver.new(tr_head2, "label:")
-
-    tr_desc = Tree.new_with_document_struct(DocumentStructure::RD)
-    de_desc = DocumentElement.new
-    tr_desc.root = de_desc
-    hl1_desc, dt1_desc = nil
-    de_desc.build do
-      hl1_desc = new(Headline, 1) do
-        new StringElement, "label1"
-      end
-      new DescList do
-        new DescListItem do
-          dt1_desc = make_term do
-            new StringElement, "label2"
-          end
-        end
-      end
-    end
-    @resolv_desc = ReferenceResolver.new(tr_desc, "Label-")
-
-    tr_empty = Tree.new_with_document_struct(DocumentStructure::RD)
-    de_empty = DocumentElement.new
-    tr_empty.root = de_empty
-    @resolv_empty = ReferenceResolver.new(tr_empty, "LABEL")
-
-    tr_arr = Tree.new_with_document_struct(DocumentStructure::RD)
-    de_arr = DocumentElement.new
-    tr_arr.root = de_arr
-
-    de_arr.build do
-      new Headline, 1 do
-        new StringElement, "a => b"
-      end
-    end
-
-    @resolv_arr = ReferenceResolver.new(tr_arr, "label:")
-
-    @rbl_head2 = RBLFile.new("test-head2")
-    @rbl_desc = RBLFile.new("test-desc")
-    @rbl_empty = RBLFile.new("test-empty")
-    @rbl_arr = RBLFile.new("test-arr")
-  end
-  
-  def test_labels_to_string
-    res = "label1 => label:0\nlabel2 => label:1"
-    assert_equal(res, RBLFile.labels_to_string(@resolv_head2))
-
-    res2 = "label1 => Label-0\nlabel2 => Label-1"
-    assert_equal(res2, RBLFile.labels_to_string(@resolv_desc))
-
-    res_empty = ""
-    assert_equal(res_empty, RBLFile.labels_to_string(@resolv_empty))
-
-    res_arr = "a => b => label:0"
-    assert_equal(res_arr, RBLFile.labels_to_string(@resolv_arr))
-  end
-
-  def test_string_to_labels
-    rbl = RBLFile.new("test-head2")
-    src_head2 = "label1 => label:0\nlabel2 => label:1"
-    res_head2 = [["label1", "label:0"], ["label2", "label:1"]]
-    assert_equal(res_head2, rbl.string_to_labels(src_head2)) 
-
-    src_head2 = "label1 =>label:0\nlabel2=> label:1"
-    res_head2 = [["label1", "label:0"], ["label2", "label:1"]]
-    assert_equal(res_head2, rbl.string_to_labels(src_head2)) 
-
-    src_desc = "label1 => Label-0\nlabel2 => Label-1"
-    res_desc = [["label1", "Label-0"], ["label2", "Label-1"]]
-    assert_equal(res_desc, rbl.string_to_labels(src_desc)) 
-
-    src_empty = ""
-    res_empty = []
-    assert_equal(res_empty, @rbl_empty.string_to_labels(src_empty)) 
-
-    src_arr = "a => b => label:0"
-    res_arr = [["a => b", "label:0"]]
-    assert_equal(res_arr, @rbl_arr.string_to_labels(src_arr)) 
-  end
-
-  def test_rbl_file_path
-    assert_equal("test-head2.rbl", RBLFile.rbl_file_path("test-head2.rd"))
-    assert_equal("test-head2.rbl", RBLFile.rbl_file_path("test-head2.rb"))
-    assert_equal("test-desc.rbl", RBLFile.rbl_file_path("test-desc"))
-  end
-
-  def test_s_create_rbl_file
-    in_temp_dir do
-      begin
-        RBLFile.create_rbl_file("test-head2.rd", @resolv_head2)
-        assert(File.exist?("test-head2.rbl"))
-      ensure
-        remove_file("test-head2.rbl")
-      end
-    end
-  end
-
-  def test_load_rbl_file
-    in_temp_dir do
-      spath = [Dir.pwd]
-      begin
-        RBLFile.create_rbl_file("test-head2.rd", @resolv_head2)
-
-        rbl_rd = RBLFile.new("test-head2.rd")
-        rbl_rd.load_rbl_file(spath)
-        res = [["label1", "label:0"], ["label2", "label:1"]]
-        assert_equal(res, rbl_rd.labels)
-        
-        rbl_no = RBLFile.new("test-head2")
-        rbl_no.load_rbl_file(spath)
-        assert_equal(res, rbl_no.labels)
-      ensure
-        remove_file("test-head2.rbl")
-      end
-    end
-  end
-
-  def test_refer
-    spath = ["test/data"]
-    rbl = RBLFile.new("label")
-    rbl.load_rbl_file(spath)
-    assert_equal("label:0", rbl.refer("label1"))
-    assert_equal("label:1", rbl.refer("label2"))
-    assert_equal(nil, rbl.refer("label3"))
-  end
-end

data/vendor/rdtool-0.6.38/test/test-rbl-suite.rb

@@ -1,43 +0,0 @@
-require 'test/unit'
-
-require 'rd/rbl-suite'
-require 'rd/rbl-file'
-
-include RD
-
-class TestRBLSuite < Test::Unit::TestCase
-  
-  def setup
-    @suite = RBLSuite.new(["test/data"])
-  end
-
-  def test_get_rbl_file
-    assert_equal([], @suite.rbl_files)
-    rbl = @suite.get_rbl_file("label.rd")
-    assert_equal(rbl, @suite.get_rbl_file("label.rd"))
-    assert_equal(1, @suite.rbl_files.size)
-  end
-
-  def test_add_rbl_file
-    assert_equal([], @suite.rbl_files)
-    rbl = @suite.add_rbl_file("label.rd")
-    assert_kind_of(RBLFile, rbl)
-    assert_equal(1, @suite.rbl_files.size)
-    assert_equal("label", @suite.rbl_files[0].filename)
-    assert_equal(rbl, @suite.rbl_files[0])
-
-    assert_nothing_raised do
-      @suite.add_rbl_file("not-exist-label.rd")
-    end
-  end
-
-  def test_refer
-    assert_equal(["label", "label:0"], @suite.refer("label1", "label.rd"))
-    assert_equal(["label2", "Label-0"], @suite.refer("label1", "label2.rd"))
-    assert_equal(["label", "label:0"], @suite.refer("label1", "label"))
-    assert_equal(["label", "label:1"], @suite.refer("label2", "label.rd"))
-    assert_equal(["label", nil], @suite.refer("label3", "label.rd"))
-    fns = @suite.rbl_files.collect{|i| i.filename }
-    assert_equal(["label", "label2"], fns)
-  end
-end

data/vendor/rdtool-0.6.38/test/test-rd2html-lib.rb

@@ -1,496 +0,0 @@
-require 'test/unit'
-
-require 'rd/rd2html-lib'
-require 'rd/tree'
-require 'rd/element'
-require 'rd/block-element'
-require 'rd/list'
-require 'rd/desclist'
-require 'rd/methodlist'
-require 'rd/inline-element'
-require 'rd/rd-struct'
-
-include RD
-
-class TestRD2HTMLVisitor < Test::Unit::TestCase
-  
-  def setup
-    @vis = RD2HTMLVisitor.new
-    @vis.class.module_eval {
-      public :xml_decl
-      public :forward_links, :backward_links
-      public :document_title
-      public :html_content_type
-      public :html_title
-      public :html_open_tag
-      public :link_to_css
-      public :prepare_footnotes
-      public :make_foottext
-    }
-    @ch1 = ["a"]
-    @ch2 = ["a", "b"]
-    @ch3 = ["a\n"]
-    @ch0 = []
-
-    @tr_fn = Tree.new_with_document_struct(DocumentStructure::RD)
-    @tr_fn.root = DocumentElement.new
-    fn1, fn2 = nil
-    @tr_fn.root.build do
-      new TextBlock do
-        fn1 = new Footnote do
-          new StringElement, "footnote 1"
-        end
-        fn2 = new Footnote do
-          new StringElement, "footnote 2"
-        end
-      end
-    end
-    @fn1_fn = fn1
-    @fn2_fn = fn2
-
-    @tr2_fn = Tree.new_with_document_struct(DocumentStructure::RD)
-    @tr2_fn.root = DocumentElement.new
-    @tr2_fn.root.build do
-      new Headline, 1
-      new TextBlock do
-        new StringElement, "string"
-      end
-    end
-  end
-
-  def test_xml_decl
-    vis_with_charset = RD2HTMLVisitor.new
-    vis_with_charset.charset = "CharSet"
-    assert_equal(%|<?xml version="1.0" encoding="CharSet" ?>|,
-                 vis_with_charset.xml_decl)
-    vis_no_charset = RD2HTMLVisitor.new
-    assert_equal(%|<?xml version="1.0" ?>|,
-                 vis_no_charset.xml_decl)
-  end
-
-  def test_html_open_tag
-    vis_with_lang = RD2HTMLVisitor.new
-    vis_with_lang.lang = "Language"
-    assert_equal(%|<html xmlns="http://www.w3.org/1999/xhtml" lang="Language"|+
-                 %| xml:lang="Language">|, vis_with_lang.html_open_tag)
-
-    vis_no_lang = RD2HTMLVisitor.new
-    assert_equal(%|<html xmlns="http://www.w3.org/1999/xhtml">|,
-                 vis_no_lang.html_open_tag)
-  end
-
-  def test_html_title
-    vis_with_title = RD2HTMLVisitor.new
-    vis_with_title.title = "Title"
-    assert_equal("<title>Title</title>", vis_with_title.html_title)
-
-    vis_no_title = RD2HTMLVisitor.new
-    assert_equal("<title>Untitled</title>", vis_no_title.html_title)
-  end
-
-  def test_html_content_type
-    vis_with_charset = RD2HTMLVisitor.new
-    vis_with_charset.charset = "CharSet"
-    assert_equal(%|<meta http-equiv="Content-type" | +
-                 %|content="text/html; charset=CharSet" | +
-                 "/>", vis_with_charset.html_content_type)
-    vis_no_charset = RD2HTMLVisitor.new
-    assert_equal(nil, vis_no_charset.html_content_type)
-  end
-
-  def test_link_to_css
-    vis_with_css = RD2HTMLVisitor.new
-    vis_with_css.css = "CSS.css"
-    assert_equal(%|<link href="CSS.css" type="text/css" rel="stylesheet"| +
-                 " />", vis_with_css.link_to_css)
-    vis_no_css = RD2HTMLVisitor.new
-    assert_equal(nil, vis_no_css.link_to_css)
-  end
-
-  def test_forward_links
-    vis_rel1 = RD2HTMLVisitor.new
-    vis_rel1.html_link_rel["rel1"] = "REL1"
-    assert_equal('<link href="REL1" rel="rel1" />', vis_rel1.forward_links)
-
-    vis_rel2 = vis_rel1
-    vis_rel2.html_link_rel["rel2"] = "REL2"
-    assert_equal('<link href="REL1" rel="rel1" />' + "\n" +
-                 '<link href="REL2" rel="rel2" />', vis_rel2.forward_links)
-
-    vis_no_rel = RD2HTMLVisitor.new
-    assert_equal(nil, vis_no_rel.forward_links)
-  end
-
-  def test_backward_links
-    vis_rev1 = RD2HTMLVisitor.new
-    vis_rev1.html_link_rev["rev1"] = "REV1"
-    assert_equal('<link href="REV1" rev="rev1" />', vis_rev1.backward_links)
-
-    vis_rev2 = vis_rev1
-    vis_rev2.html_link_rev["rev2"] = "REV2"
-    assert_equal('<link href="REV1" rev="rev1" />' + "\n" +
-                 '<link href="REV2" rev="rev2" />', vis_rev2.backward_links)
-
-    vis_no_rev = RD2HTMLVisitor.new
-    assert_equal(nil, vis_no_rev.backward_links)
-  end
-
-
-  def test_document_title
-    vis_titled = RD2HTMLVisitor.new
-    vis_titled.title = "Title"
-    assert_equal("Title", vis_titled.document_title)
-    
-    vis_with_filename = RD2HTMLVisitor.new
-    vis_with_filename.filename = "FileName"
-    assert_equal("FileName", vis_with_filename.document_title)
-
-    vis_untitled = RD2HTMLVisitor.new
-    assert_equal("Untitled", vis_untitled.document_title)
-  end
-  
-  def test_apply_to_Headline
-    tr = Tree.new_with_document_struct(DocumentStructure::RD)
-    tr.root = DocumentElement.new
-    hl1, hl2 = nil
-    tr.root.build do
-      hl1 = new Headline, 1 do
-        new StringElement, "headline 1"
-      end
-      hl2 = new Headline, 2 do
-        new StringElement, "headline 2"
-      end
-    end
-    @vis.prepare_labels(tr, "label:")
-
-    assert_equal(expect_for_hl1(@ch1), @vis.apply_to_Headline(hl1, @ch1))
-    assert_equal(expect_for_hl1(@ch2), @vis.apply_to_Headline(hl1, @ch2))
-    assert_equal(expect_for_hl1(@ch0), @vis.apply_to_Headline(hl1, @ch0))
-    assert_equal(expect_for_hl2(@ch1), @vis.apply_to_Headline(hl2, @ch1))
-    assert_equal(expect_for_hl2(@ch2), @vis.apply_to_Headline(hl2, @ch2))
-    assert_equal(expect_for_hl2(@ch0), @vis.apply_to_Headline(hl2, @ch0))
-  end
-
-  def expect_for_hl1(children)
-    %|<h1><a name="label:0" id="label:0">#{children.join('')}</a></h1><!-- RDLabel: "headline 1" -->|
-  end
-
-  def expect_for_hl2(children)
-    %|<h2><a name="label:1" id="label:1">#{children.join('')}</a></h2><!-- RDLabel: "headline 2" -->|
-  end
-
-  def test_apply_to_TextBlock
-    tb = TextBlock.new
-    assert_equal("<p>a</p>", @vis.apply_to_TextBlock(tb, @ch1))
-    assert_equal("<p>ab</p>", @vis.apply_to_TextBlock(tb, @ch2))
-    assert_equal("<p>a</p>", @vis.apply_to_TextBlock(tb, @ch3))
-    assert_equal("<p></p>", @vis.apply_to_TextBlock(tb, @ch0))
-
-    tb_in_list = TextBlock.new
-    li = ItemListItem.new
-    li.add_child_under_document_struct(tb_in_list, DocumentStructure::RD)
-    assert_equal("a", @vis.apply_to_TextBlock(tb_in_list, @ch1))
-    assert_equal("ab", @vis.apply_to_TextBlock(tb_in_list, @ch2))
-    assert_equal("a", @vis.apply_to_TextBlock(tb_in_list, @ch3))
-    assert_equal("", @vis.apply_to_TextBlock(tb_in_list, @ch0))
-
-    tb1_in_list2 = TextBlock.new
-    tb2_in_list2 = TextBlock.new    
-    li2 = ItemListItem.new
-    li2.add_children_under_document_struct([tb1_in_list2, tb2_in_list2],
-                                           DocumentStructure::RD)
-    assert_equal("<p>a</p>", @vis.apply_to_TextBlock(tb1_in_list2, @ch1))
-    assert_equal("<p>ab</p>", @vis.apply_to_TextBlock(tb1_in_list2, @ch2))
-    assert_equal("<p>a</p>", @vis.apply_to_TextBlock(tb1_in_list2, @ch3))
-    assert_equal("<p></p>", @vis.apply_to_TextBlock(tb1_in_list2, @ch0))
-  end
-
-  def test_apply_to_Verbatim
-    verb1 = Verbatim.new "aaa"
-    assert_equal("<pre>aaa</pre>", @vis.apply_to_Verbatim(verb1))
-    verb2 = Verbatim.new "aaa\n"
-    assert_equal("<pre>aaa</pre>", @vis.apply_to_Verbatim(verb2))
-    verb3 = Verbatim.new "aaa\nbbb"
-    assert_equal("<pre>aaa\nbbb</pre>", @vis.apply_to_Verbatim(verb3))
-    verb_empty = Verbatim.new ""
-    assert_equal("<pre></pre>", @vis.apply_to_Verbatim(verb_empty))
-    verb_amp = Verbatim.new "&"
-    assert_equal("<pre>&amp;</pre>", @vis.apply_to_Verbatim(verb_amp))
-    verb_lt = Verbatim.new "<"
-    assert_equal("<pre>&lt;</pre>", @vis.apply_to_Verbatim(verb_lt))
-    verb_gt = Verbatim.new ">"
-    assert_equal("<pre>&gt;</pre>", @vis.apply_to_Verbatim(verb_gt))
-
-    verb3 = Verbatim.new ["aaa\n", "bbb"]
-    assert_equal("<pre>aaa\nbbb</pre>", @vis.apply_to_Verbatim(verb3))
-  end
-
-  def test_apply_to_ItemList
-    list = ItemList.new
-    assert_equal("<ul>\na\n</ul>", @vis.apply_to_ItemList(list, @ch1))
-    assert_equal("<ul>\na\nb\n</ul>", @vis.apply_to_ItemList(list, @ch2))
-    assert_equal("<ul>\na\n</ul>", @vis.apply_to_ItemList(list, @ch3))
-    assert_equal("<ul>\n\n</ul>", @vis.apply_to_ItemList(list, @ch0))
-  end
-
-  def test_apply_to_EnumList
-    list = EnumList.new
-    assert_equal("<ol>\na\n</ol>", @vis.apply_to_EnumList(list, @ch1))
-    assert_equal("<ol>\na\nb\n</ol>", @vis.apply_to_EnumList(list, @ch2))
-    assert_equal("<ol>\na\n</ol>", @vis.apply_to_EnumList(list, @ch3))
-    assert_equal("<ol>\n\n</ol>", @vis.apply_to_EnumList(list, @ch0))
-  end
-
-  def test_apply_to_DescList
-    list = DescList.new
-    assert_equal("<dl>\na\n</dl>", @vis.apply_to_DescList(list, @ch1))
-    assert_equal("<dl>\na\nb\n</dl>", @vis.apply_to_DescList(list, @ch2))
-    assert_equal("<dl>\na\n</dl>", @vis.apply_to_DescList(list, @ch3))
-    assert_equal("<dl>\n\n</dl>", @vis.apply_to_DescList(list, @ch0))
-  end
-
-  def test_apply_to_MethodList
-    list = MethodList.new
-    assert_equal("<dl>\na\n</dl>", @vis.apply_to_MethodList(list, @ch1))
-    assert_equal("<dl>\na\nb\n</dl>", @vis.apply_to_MethodList(list, @ch2))
-    assert_equal("<dl>\na\n</dl>", @vis.apply_to_MethodList(list, @ch3))
-    assert_equal("<dl>\n\n</dl>", @vis.apply_to_MethodList(list, @ch0))
-  end
-
-  def test_apply_to_ItemListItem
-    item = ItemListItem.new
-    assert_equal("<li>a</li>", @vis.apply_to_ItemListItem(item, @ch1))
-    assert_equal("<li>a\nb</li>", @vis.apply_to_ItemListItem(item, @ch2))
-    assert_equal("<li>a</li>", @vis.apply_to_ItemListItem(item, @ch3))
-    assert_equal("<li></li>", @vis.apply_to_ItemListItem(item, @ch0))
-  end
-
-  def test_apply_to_EnumListItem
-    item = EnumListItem.new
-    assert_equal("<li>a</li>", @vis.apply_to_EnumListItem(item, @ch1))
-    assert_equal("<li>a\nb</li>", @vis.apply_to_EnumListItem(item, @ch2))
-    assert_equal("<li>a</li>", @vis.apply_to_EnumListItem(item, @ch3))
-    assert_equal("<li></li>", @vis.apply_to_EnumListItem(item, @ch0))
-  end
-
-  def test_apply_to_DescListItem
-    tr = Tree.new_with_document_struct(DocumentStructure::RD)
-    tr.root = DocumentElement.new
-    di1, di2 = nil
-    tr.root.build do
-      new DescList do
-        di1 = new DescListItem do
-          make_term do
-            new StringElement, "desclist 1"
-          end
-        end
-        di2 = new DescListItem do
-          make_term do
-            new StringElement, "desclist 2"
-          end
-        end
-      end
-    end
-
-    @vis.prepare_labels(tr, "label:")
-
-    assert_equal(expect_for_di1_with_child("term1", @ch1),
-                 @vis.apply_to_DescListItem(di1, ["term1"], @ch1))
-    assert_equal(expect_for_di1_with_child("term1term2", @ch1),
-                 @vis.apply_to_DescListItem(di1, ["term1", "term2"], @ch1))
-    assert_equal(expect_for_di1_with_child("term1", @ch2),
-                 @vis.apply_to_DescListItem(di1, ["term1"], @ch2))
-    assert_equal(expect_for_di1_with_child("term1", @ch3),
-                 @vis.apply_to_DescListItem(di1, ["term1"], @ch3))
-    assert_equal(expect_for_di1_no_child("term1"),
-                 @vis.apply_to_DescListItem(di1, ["term1"], @ch0))
-    assert_equal(expect_for_di1_no_child("term1term2"),
-                 @vis.apply_to_DescListItem(di1, ["term1", "term2"], @ch0))
-    assert_equal(expect_for_di2_with_child("term1", @ch1),
-                 @vis.apply_to_DescListItem(di2, ["term1"], @ch1))
-    assert_equal(expect_for_di2_no_child("term1"),
-                 @vis.apply_to_DescListItem(di2, ["term1"], @ch0))
-
-  end
-
-  def expect_for_di1_with_child(term, children)
-    %|<dt><a name="label:0" id="label:0">#{term}</a></dt><!-- RDLabel: "desclist 1" -->\n| +
-      %|<dd>\n#{children.join("\n").chomp}\n</dd>|
-  end
-
-  def expect_for_di1_no_child(term)
-    %|<dt><a name="label:0" id="label:0">#{term}</a></dt><!-- RDLabel: "desclist 1" -->|
-  end
-
-  def expect_for_di2_with_child(term, children)
-    %|<dt><a name="label:1" id="label:1">#{term}</a></dt><!-- RDLabel: "desclist 2" -->\n| +
-      %|<dd>\n#{children.join("\n").chomp}\n</dd>|
-  end
-
-  def expect_for_di2_no_child(term)
-    %|<dt><a name="label:1" id="label:1">#{term}</a></dt><!-- RDLabel: "desclist 2" -->|
-  end
-
-  # MethodListItem ...
-
-  def check_apply_to_NonterminalInline(type, tag)
-    element = type.new
-    name = type.to_s.sub(/RD::/, "")
-
-    assert_equal("<#{tag}>a</#{tag}>",
-                 @vis.send("apply_to_#{name}", element, @ch1))
-    assert_equal("<#{tag}>ab</#{tag}>",
-                 @vis.send("apply_to_#{name}", element, @ch2))
-    assert_equal("<#{tag}>a\n</#{tag}>",
-                 @vis.send("apply_to_#{name}", element, @ch3))
-    assert_equal("<#{tag}></#{tag}>",
-                 @vis.send("apply_to_#{name}", element, @ch0))
-  end
-
-  def test_apply_to_Emphasis
-    check_apply_to_NonterminalInline(Emphasis, "em")
-  end
-
-  def test_apply_to_Code
-    check_apply_to_NonterminalInline(Code, "code")
-  end
-
-  def test_apply_to_Var
-    check_apply_to_NonterminalInline(Var, "var")
-  end
-
-  def test_apply_to_Keyboard
-    check_apply_to_NonterminalInline(Keyboard, "kbd")
-  end
-
-  def test_apply_to_StringElement
-    se1 = StringElement.new "a"
-    assert_equal("a", @vis.apply_to_StringElement(se1))
-    se2 = StringElement.new "a\nb"
-    assert_equal("a\nb", @vis.apply_to_StringElement(se2))
-    se_empty = StringElement.new ""
-    assert_equal("", @vis.apply_to_StringElement(se_empty))
-    se_ws = StringElement.new " "
-    assert_equal(" ", @vis.apply_to_StringElement(se_ws))
-    se_lt = StringElement.new "<"
-    assert_equal("&lt;", @vis.apply_to_StringElement(se_lt))
-    se_gt = StringElement.new ">"
-    assert_equal("&gt;", @vis.apply_to_StringElement(se_gt))
-    se_amp = StringElement.new "&"
-    assert_equal("&amp;", @vis.apply_to_StringElement(se_amp))
-  end
-
-  def test_apply_to_Verb
-    verb1 = Verb.new "a"
-    assert_equal("a", @vis.apply_to_Verb(verb1))
-    verb2 = Verb.new "a\nb"
-    assert_equal("a\nb", @vis.apply_to_Verb(verb2))
-    verb_empty = Verb.new ""
-    assert_equal("", @vis.apply_to_Verb(verb_empty))
-    verb_ws = Verb.new " "
-    assert_equal(" ", @vis.apply_to_Verb(verb_ws))
-    verb_lt = Verb.new "<"
-    assert_equal("&lt;", @vis.apply_to_Verb(verb_lt))
-    verb_gt = Verb.new ">"
-    assert_equal("&gt;", @vis.apply_to_Verb(verb_gt))
-    verb_amp = Verb.new "&"
-    assert_equal("&amp;", @vis.apply_to_Verb(verb_amp))
-  end
-
-  def test_apply_to_Footnote
-    @vis.prepare_footnotes(@tr_fn)
-    assert_equal([], @vis.foottexts)
-
-    assert_equal(expect_for_footnote(1),
-                 @vis.apply_to_Footnote(@fn1_fn, ["footnote 1"]))
-    assert_equal([["footnote 1"]], @vis.foottexts)
-
-    assert_equal(expect_for_footnote(2),
-                 @vis.apply_to_Footnote(@fn2_fn, ["footnote", " 2"]))
-    assert_equal([["footnote 1"], ["footnote", " 2"]], @vis.foottexts)
-
-    @vis.prepare_footnotes(@tr2_fn)
-    assert_raises(ArgumentError) do
-      @vis.apply_to_Footnote(@fn2_fn, [])
-    end
-  end
-
-  def expect_for_footnote(num)
-    %Q|<a name="footmark-#{num}" id="footmark-#{num}" href="#foottext-#{num}">|+
-      %Q|<sup><small>*#{num}</small></sup></a>|
-  end
-
-  def test_get_footnote_num
-    @vis.prepare_footnotes(@tr_fn)
-    assert_equal(1, @vis.get_footnote_num(@fn1_fn))
-    assert_equal(2, @vis.get_footnote_num(@fn2_fn))
-    assert_equal(nil, @vis.get_footnote_num(Footnote.new))
-    @vis.prepare_footnotes(@tr2_fn)
-    assert_equal(nil, @vis.get_footnote_num(@fn1_fn))
-
-    assert_raises(ArgumentError) do
-      @vis.get_footnote_num(Headline.new(1))
-    end
-  end
-
-  def test_prepare_footnotes
-    @vis.prepare_footnotes(@tr_fn)
-    assert_equal([@fn1_fn, @fn2_fn], @vis.footnotes)
-
-    @vis.prepare_footnotes(@tr2_fn)
-    assert_equal([], @vis.footnotes)
-  end
-
-  def test_add_foottext
-    @vis.prepare_footnotes(@tr_fn)
-    assert_equal([], @vis.foottexts)    
-    @vis.add_foottext(@vis.get_footnote_num(@fn1_fn), ["footnote 1"])
-    assert_equal([["footnote 1"]], @vis.foottexts)
-    @vis.add_foottext(@vis.get_footnote_num(@fn2_fn), ["footnote", "2"])
-    assert_equal([["footnote 1"], ["footnote", "2"]], @vis.foottexts)
-    assert_raises(ArgumentError) do
-      @vis.add_foottext(3, "footnote 3")
-    end
-  end
-
-  def test_apply_to_Foottext
-    @vis.prepare_footnotes(@tr_fn)
-    
-    exp1 = %|<a name="foottext-1" id="foottext-1" href="#footmark-1">| +
-      %|<sup><small>*1</small></sup></a>| +
-      %|<small>footnote 1</small><br />|
-    assert_equal(exp1, @vis.apply_to_Foottext(@fn1_fn, ["footnote 1"]))
-    exp2 = %|<a name="foottext-2" id="foottext-2" href="#footmark-2">| +
-      %|<sup><small>*2</small></sup></a>| +
-      %|<small>footnote 2</small><br />|
-    assert_equal(exp2, @vis.apply_to_Foottext(@fn2_fn, ["footnote", " 2"]))
-
-    @vis.prepare_footnotes(@tr2_fn)
-    assert_raises(ArgumentError) do
-      @vis.apply_to_Foottext(@fn1_fn, ["footnote 1"])
-    end
-  end
-
-  def test_make_foottext
-    @vis.prepare_footnotes(@tr_fn)
-    ft1 = ["footnote 1"]
-    ft2 = ["footnote", " 2"]
-    @vis.add_foottext(@vis.get_footnote_num(@fn1_fn), ft1)
-    @vis.add_foottext(@vis.get_footnote_num(@fn2_fn), ft2)
-    exp1 = @vis.apply_to_Foottext(@fn1_fn, ft1)
-    exp2 = @vis.apply_to_Foottext(@fn2_fn, ft2)
-    assert_equal(%|<hr />\n<p class="foottext">\n#{exp1}\n#{exp2}\n</p>|, @vis.make_foottext)
-
-    @vis.prepare_footnotes(@tr2_fn)
-    assert_equal(nil, @vis.make_foottext)
-  end
-
-  def test_hyphen_escape
-    assert_equal("&shy;&shy;", @vis.hyphen_escape("--"))
-    assert_equal("-", @vis.hyphen_escape("-"))
-    assert_equal("&shy;&shy;-", @vis.hyphen_escape("---"))
-    assert_equal("- -", @vis.hyphen_escape("- -"))
-    assert_equal("aa&shy;&shy;bb", @vis.hyphen_escape("aa--bb"))
-    assert_equal("", @vis.hyphen_escape(""))
-  end
-end