tdiary 3.2.2.20130518 → 3.2.2.20130527

data/vendor/rdtool-0.6.38/test/test-element.rb

@@ -1,46 +0,0 @@
-require 'test/unit'
-
-require 'rd/tree'
-require 'rd/element'
-require 'rd/rd-struct'
-
-include RD
-
-class TestElement < Test::Unit::TestCase
-
-  def setup
-    @tree = Tree.new_with_document_struct(DocumentStructure::RD)
-    @de = DocumentElement.new
-    @tree.root = @de
-    @tb = TextBlock.new
-    @de.add_child(@tb)
-
-    @err = TextBlock.new
-  end
-
-  def test_tree
-    assert_equal(@tree, @de.tree)
-    assert_equal(@tree, @tb.tree)
-    assert_raises(RuntimeError) do
-      @err.tree
-    end
-  end
-
-  def test_inspect
-    assert_equal("<RD::TextBlock>", TextBlock.new.inspect)
-
-    t = TextBlock.new
-    s = StringElement.new ""
-    t.add_child_under_document_struct(s, DocumentStructure::RD)
-    assert_equal("<RD::TextBlock>\n  <RD::StringElement>", t.inspect)
-
-    t = TextBlock.new
-    e = Emphasis.new
-    s = StringElement.new ""
-    s2 = StringElement.new "a"
-    e.add_child_under_document_struct(s, DocumentStructure::RD)
-    t.add_children_under_document_struct([e, s2], DocumentStructure::RD)
-    exp = "<RD::TextBlock>\n  <RD::Emphasis>\n    <RD::StringElement>\n  <RD::StringElement>"
-    assert_equal(exp, t.inspect)
-  end
-end

data/vendor/rdtool-0.6.38/test/test-headline.rb

@@ -1,80 +0,0 @@
-require 'test/unit'
-
-require 'rd/block-element'
-require 'rd/inline-element'
-require 'rd/rd-struct'
-require 'rd/document-struct'
-
-include RD
-
-class TestHeadline < Test::Unit::TestCase
-  
-  def test_s_new
-    a = Headline.new(1)
-    assert_equal(1, a.level)
-  end
-
-  def test_add_child_under_document_struct
-    check_add_child(StringElement.new(""))
-    check_add_child(Emphasis.new)
-    check_add_child(Code.new)
-    check_add_child(Var.new)
-    check_add_child(Keyboard.new)
-    check_add_child(Index.new)
-    check_add_child(Verb.new(""))
-    check_add_child_fail(TextBlock.new)
-    check_add_child_fail(Verbatim.new)
-    check_add_child_fail(ItemList.new)
-    check_add_child_fail(ItemListItem.new)
-    check_add_child_fail(Reference.new(Reference::RDLabel.new("")))
-    check_add_child_fail(Footnote.new)
-  end
-
-  def check_add_child(child)
-    parent = Headline.new(1)
-    parent.add_child_under_document_struct(child, DocumentStructure::RD)
-    assert_equal([child], parent.children)
-    assert_equal(parent, child.parent)
-  end
-
-  def check_add_child_fail(child)
-    parent = Headline.new(1)
-    assert_raises(ArgumentError) do
-      parent.add_child_under_document_struct(child, DocumentStructure::RD)
-    end
-  end
-
-  def test_to_label
-    a = Headline.new(1)
-    c1 = StringElement.new "label"
-    a.add_child_under_document_struct(c1, DocumentStructure::RD)
-    assert_equal("label", a.to_label)
-
-    b = Headline.new(1)
-    c2 = Emphasis.new
-    c21 = StringElement.new "LABEL"
-    c2.add_child_under_document_struct(c21, DocumentStructure::RD)
-    b.add_children_under_document_struct([c1, c2], DocumentStructure::RD)
-    assert_equal("labelLABEL", b.to_label)
-
-    b = Headline.new(1)
-    c2 = Code.new
-    c21 = StringElement.new " LABEL "
-    c2.add_child_under_document_struct(c21, DocumentStructure::RD)
-    b.add_children_under_document_struct([c1, c2], DocumentStructure::RD)
-    assert_equal("labelLABEL", b.to_label)
-  end
-
-  def test_s_mark_to_level
-    assert_equal(1, Headline.mark_to_level("="))
-    assert_equal(2, Headline.mark_to_level("=="))
-    assert_equal(3, Headline.mark_to_level("==="))
-    assert_equal(4, Headline.mark_to_level("===="))
-    assert_equal(5, Headline.mark_to_level("+"))
-    assert_equal(6, Headline.mark_to_level("++"))
-
-    assert_raises(ArgumentError) do
-      Headline.mark_to_level("=====")
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-require 'test/unit'
-
-require 'rd/rdinlineparser.tab'
-require 'rd/rd-struct'
-
-include RD
-
-class TestInlineParser < Test::Unit::TestCase
-  def setup
-    @block_parser = RDParser.new
-    @tree = tree = Tree.new_with_document_struct(DocumentStructure::RD)
-    @block_parser.instance_eval do
-      @tree = tree
-    end
-
-    @inline_parser = RDInlineParser.new(@block_parser)
-  end
-
-  def test_tree
-    assert_equal(@tree, @inline_parser.tree)
-  end
-
-  def test_make_reference_from_label
-    label = Reference::TemporaryLabel.new([StringElement.new("label")])
-    expect = Reference.new_from_label_under_document_struct(label,
-                        DocumentStructure::RD)
-    ref = @inline_parser.make_reference_from_label(label)
-    assert_equal(expect.label.element_label, ref.label.element_label)
-    assert_equal(expect.label.filename, ref.label.filename)
-  end
-
-  def test_prev_words_on_error
-    @inline_parser.instance_eval{@pre="foo bar baz"}
-    assert_equal("foo bar baz", @inline_parser.prev_words_on_error("foo"))
-    assert_equal("foo bar ", @inline_parser.prev_words_on_error("baz"))
-    assert_equal("foo bar baz", @inline_parser.prev_words_on_error(false))
-    assert_equal("foo bar baz", @inline_parser.prev_words_on_error("not exist"))
-    @inline_parser.instance_eval{@pre="foo bar\nfoo2 bar2"}
-    assert_equal("foo2 bar2", @inline_parser.prev_words_on_error("foo2"))
-    assert_equal("foo2 ", @inline_parser.prev_words_on_error("bar2"))
-
-    @inline_parser.instance_eval{@pre="foo?"}
-    assert_equal("foo", @inline_parser.prev_words_on_error("?"))
-  end
-end
-

data/vendor/rdtool-0.6.38/test/test-list-item.rb

@@ -1,54 +0,0 @@
-require 'test/unit'
-
-require 'rd/list.rb'
-require 'rd/rd-struct'
-
-include RD
-
-class TestListItem < Test::Unit::TestCase
-  def setup
-    @a = ItemListItem.new
-    @c1 = TextBlock.new
-    @c2 = TextBlock.new
-    @a.add_children_under_document_struct([@c1, @c2], DocumentStructure::RD)
-
-    @b = ItemListItem.new
-    @d1 = TextBlock.new
-    @d11 = Emphasis.new
-    @d1.add_child_under_document_struct(@d11, DocumentStructure::RD)
-    @b.add_children_under_document_struct([@d1], DocumentStructure::RD)
-  end
-  
-  def test_each_block
-    exp = [@c1, @c2]
-    i = 0
-    @a.each_block do |b|
-      assert_equal(exp[i], b)
-      i += 1
-    end
-
-    exp = [@d1]
-    i = 0
-    @b.each_block do |b|
-      assert_equal(exp[i], b)
-      i += 1
-    end
-  end
-
-  def test_each_element
-    exp = [@a, @c1, @c2]
-    i = 0
-    @a.each_element do |b|
-      assert_equal(exp[i], b)
-      i += 1
-    end
-
-    exp = [@b, @d1, @d11]
-    i = 0
-    @b.each_element do |b|
-      assert_equal(exp[i], b)
-      i += 1
-    end
-  end
-
-end

data/vendor/rdtool-0.6.38/test/test-list.rb

@@ -1,53 +0,0 @@
-require 'test/unit'
-
-require 'rd/list.rb'
-require 'rd/rd-struct'
-
-include RD
-
-class TestList < Test::Unit::TestCase
-  def setup
-    @a = ItemList.new
-    @c1 = ItemListItem.new
-    @c2 = ItemListItem.new
-    @a.add_children_under_document_struct([@c1, @c2], DocumentStructure::RD)
-
-    @b = ItemList.new
-    @d1 = ItemListItem.new
-    @d11 = TextBlock.new
-    @d1.add_child_under_document_struct(@d11, DocumentStructure::RD)
-    @b.add_children_under_document_struct([@d1], DocumentStructure::RD)
-  end
-  
-  def test_each_item
-    exp = [@c1, @c2]
-    i = 0
-    @a.each_item do |b|
-      assert_equal(exp[i], b)
-      i += 1
-    end
-
-    exp = [@d1]
-    i = 0
-    @b.each_item do |b|
-      assert_equal(exp[i], b)
-      i += 1
-    end
-  end
-
-  def test_each_element
-    exp = [@a, @c1, @c2]
-    i = 0
-    @a.each_element do |b|
-      assert_equal(exp[i], b)
-      i += 1
-    end
-
-    exp = [@b, @d1, @d11]
-    i = 0
-    @b.each_element do |b|
-      assert_equal(exp[i], b)
-      i += 1
-    end
-  end
-end

data/vendor/rdtool-0.6.38/test/test-methodlist-item.rb

@@ -1,73 +0,0 @@
-require 'test/unit'
-
-require 'rd/methodlist'
-require 'rd/rd-struct'
-
-include RD
-
-class TestMethodListItem < Test::Unit::TestCase
-  def test_set_term
-    p = MethodListItem.new
-    c = MethodListItem::Term.new
-    p.set_term_under_document_struct(c, DocumentStructure::RD)
-    assert_equal(c, p.term)
-    assert_equal(p, c.parent)
-  end
-
-  def test_make_term
-    tr = Tree.new_with_document_struct(DocumentStructure::RD)
-    de = DocumentElement.new
-    tr.root = de
-    di, dt = nil
-    de.build do
-      new MethodList do
-        di = new MethodListItem do
-          dt = make_term
-        end
-      end
-    end
-    assert_equal("<RD::MethodListItem>\n  <RD::MethodListItem::Term>",
-                 di.inspect)
-    assert_equal(di.term, dt)
-  end
-
-  def test_inspect
-    mi = MethodListItem.new
-    mt = MethodListItem::Term.new
-    se = StringElement.new "string"
-    tb = TextBlock.new
-    mi.set_term_under_document_struct(mt, DocumentStructure::RD)
-    mi.add_child_under_document_struct(tb, DocumentStructure::RD)
-    assert_equal("<RD::MethodListItem>\n  <RD::MethodListItem::Term>\n" +
-                 "  <RD::TextBlock>", mi.inspect)
-    
-    mi_no_desc = MethodListItem.new
-    mt_no_desc = MethodListItem::Term.new
-    mi_no_desc.set_term_under_document_struct(mt_no_desc,
-                                              DocumentStructure::RD)
-    assert_equal("<RD::MethodListItem>\n  <RD::MethodListItem::Term>",
-                 mi_no_desc.inspect)
-
-    mi_no_term = MethodListItem.new
-    mi_no_term.add_child_under_document_struct(TextBlock.new,
-                                               DocumentStructure::RD)
-    assert_equal("<RD::MethodListItem>\n  <RD::TextBlock>",
-                 mi_no_term.inspect)
-    assert_equal("<RD::MethodListItem>", MethodListItem.new.inspect)
-  end
-
-end
-
-class TestMethodListItemTerm < Test::Unit::TestCase
-  def test_to_label
-    assert_equal("", MethodListItem::Term.new.to_label)
-    assert_equal("foo", MethodListItem::Term.new("foo").to_label)
-    assert_equal("foo", MethodListItem::Term.new("foo()").to_label)
-    assert_equal("foo", MethodListItem::Term.new("foo(arg)").to_label)
-    assert_equal("Foo#foo", MethodListItem::Term.new("Foo#foo(arg)").to_label)
-    assert_equal("Foo::foo", MethodListItem::Term.new("Foo::foo(arg)").to_label)    
-    assert_equal("foo", MethodListItem::Term.new("foo{|arg| ...}").to_label)
-    assert_equal("foo", MethodListItem::Term.new("foo(arg){|arg| ...}").to_label)
-    assert_equal("foo", MethodListItem::Term.new("foo  (arg)").to_label)
-  end
-end

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

@@ -1,170 +0,0 @@
-require 'test/unit'
-
-require 'rd/tree'
-require 'rd/element'
-require 'rd/loose-struct'
-require 'rd/rd-struct'
-
-include RD
-
-class TestElement < Test::Unit::TestCase
-  
-  def test_add_child_under_document_struct
-    check_add_child(TextBlock.new, StringElement.new(""))
-    check_add_child(Headline.new(1), Emphasis.new)
-    check_add_child(ItemList.new, ItemListItem.new)
-    check_add_child(ItemListItem.new, TextBlock.new)
-    check_add_child(Emphasis.new, Code.new)
-
-    assert_raises(ArgumentError) do
-      Headline.new.add_child_under_document_struct(Reference.
-                                                 new(Reference::RDLabel.new),
-                                                 DocumentStructure::RD)
-      ItemListItem.new.add_child_under_document_struct(Headline.new,
-                                                 DocumentStructure::RD)
-    end
-  end
-
-  def check_add_child(p, c)
-    assert(p.add_child_under_document_struct(c, DocumentStructure::RD))
-  end
-
-  def test_add_children_under_document_struct
-    p = TextBlock.new
-    c1 = Code.new
-    c2 = Var.new
-    c3 = Reference.new(Reference::RDLabel.new(""))
-    p.add_children_under_document_struct([c1, c2, c3], DocumentStructure::RD)
-    assert_equal([c1, c2, c3], p.children)
-    [c1, c2, c3].each do |i|
-      assert_equal(p, i.parent)
-    end
-  end
-
-  def test_add_child_under_document_struct2
-    p = TextBlock.new
-    assert_equal([], p.children)
-
-    c1 = Emphasis.new
-    p.add_child_under_document_struct(c1, DocumentStructure::RD)
-    assert_equal([c1], p.children)
-    assert_equal(p, c1.parent)
-
-    c2 = StringElement.new("")
-    p.add_child_under_document_struct(c2, DocumentStructure::RD)
-    assert_equal([c1, c2], p.children)
-    assert_equal(p, c2.parent)
-
-    p = DocumentElement.new
-    c1 = Headline.new(1)
-    p.add_child_under_document_struct(c1, DocumentStructure::RD)
-    assert_equal([c1], p.children)
-    assert_equal(p, c1.parent)
-
-    c2 = ItemList.new
-    p.add_child_under_document_struct(c2, DocumentStructure::RD)
-    assert_equal([c1, c2], p.children)
-    assert_equal(p, c2.parent)
-  end
-
-  def test_add_children_without_document_struct
-    p = TextBlock.new
-    c1 = StringElement.new "string"
-    c2 = Emphasis.new
-    c3 = Headline.new(1)
-
-    assert_equal([], p.children)
-    p.add_children_without_document_struct([c1])
-    assert_equal([c1], p.children)
-    assert_equal(p, c1.parent)
-    p.add_children_without_document_struct([c1, c2])
-    assert_equal([c1, c1, c2], p.children)
-    assert_equal(p, c2.parent)
-    p.add_children_without_document_struct([c3])
-    assert_equal([c1, c1, c2, c3], p.children)
-    assert_equal(p, c2.parent)
-  end
-
-  def test_push_to_children
-    parent = TextBlock.new
-    child1 = StringElement.new "string"
-    parent.push_to_children(child1)
-    assert_equal([child1], parent.children)
-    assert_equal(parent, child1.parent)
-  end
-
-  def test_children
-    assert_equal([], DocumentElement.new.children)
-    assert_equal([], Headline.new(1).children)
-    assert_equal([], TextBlock.new.children)
-    assert_equal([], List.new.children)
-    assert_equal([], ListItem.new.children)
-    assert_equal([], DescListItem::Term.new.children)
-    assert_equal([], NonterminalInline.new.children)
-  end
-
-  def test_build
-    testcase = self
-    tr = Tree.new_with_document_struct(DocumentStructure::RD)
-    de = DocumentElement.new
-    tr.root = de
-    tb = TextBlock.new
-    de.add_child(tb)
-    res = tb.build do
-      testcase.assert_equal(tb, self)
-    end
-    assert_equal(tb, res)
-  end
-
-  def test_build_under_document_struct
-    testcase = self
-    tb = TextBlock.new
-    assert_nothing_raised do 
-      tb.build(DocumentStructure::LOOSE) do
-        testcase.assert_equal(DocumentStructure::LOOSE,
-                              tb.temporary_document_structure)
-        new Headline, 1
-      end
-    end
-    assert_equal(nil, tb.temporary_document_structure)
-
-    begin
-      tb.build(DocumentStructure::LOOSE) do
-        raise RuntimeError
-      end
-    rescue
-      assert_equal(nil, tb.temporary_document_structure)
-    end
-  end
-
-  def test_make_child
-    tr = Tree.new_with_document_struct(DocumentStructure::RD)
-    de = DocumentElement.new
-    tb = TextBlock.new
-    tr.root = de
-    de.add_child(tb)
-    
-    tb.make_child(StringElement, "string")
-    assert_equal("<RD::TextBlock>\n  <RD::StringElement>", tb.inspect)
-
-    assert_raises(ArgumentError) do
-      tb.make_child(TextBlock)
-    end
-
-    tr2 = Tree.new_with_document_struct(DocumentStructure::RD)
-    de2 = DocumentElement.new
-    tr2.root = de2
-
-    de2.build do
-      new TextBlock do
-        new StringElement, "string"
-        new Emphasis do
-          new StringElement, "emphais"
-        end
-      end
-    end
-    assert_equal("<RD::DocumentElement>\n  <RD::TextBlock>\n" +
-                 "    <RD::StringElement>\n    <RD::Emphasis>\n      " +
-                 "<RD::StringElement>", de2.inspect)
-  end
-end