rdoc 2.4.3 → 2.5

data/test/hidden.zip.txt

@@ -0,0 +1 @@
+PK

data/test/test_attribute_manager.rb

@@ -1,5 +1,7 @@
 require 'rubygems'
-require 'minitest/unit'
+require 'minitest/autorun'
+require 'rdoc'
+require 'rdoc/markup'
 require 'rdoc/markup/attribute_manager'
 
 class TestAttributeManager < MiniTest::Unit::TestCase
@@ -9,29 +11,21 @@ class TestAttributeManager < MiniTest::Unit::TestCase
     @klass = RDoc::Markup::AttributeManager
   end
 
-  def teardown
-    silently do
-      @klass.const_set(:MATCHING_WORD_PAIRS, {})
-      @klass.const_set(:WORD_PAIR_MAP, {})
-      @klass.const_set(:HTML_TAGS, {})
-    end
-  end
-
   def test_initial_word_pairs
-    word_pairs = @klass::MATCHING_WORD_PAIRS
+    word_pairs = @am.matching_word_pairs
     assert word_pairs.is_a?(Hash)
     assert_equal(3, word_pairs.size)
   end
 
   def test_initial_html
-    html_tags = @klass::HTML_TAGS
+    html_tags = @am.html_tags
     assert html_tags.is_a?(Hash)
     assert_equal(5, html_tags.size)
   end
 
   def test_add_matching_word_pair
     @am.add_word_pair("x","x", :TEST)
-    word_pairs = @klass::MATCHING_WORD_PAIRS
+    word_pairs = @am.matching_word_pairs
     assert_equal(4,word_pairs.size)
     assert(word_pairs.has_key?("x"))
   end
@@ -44,21 +38,21 @@ class TestAttributeManager < MiniTest::Unit::TestCase
 
   def test_add_word_pair_map
     @am.add_word_pair("x", "y", :TEST)
-    word_pair_map = @klass::WORD_PAIR_MAP
+    word_pair_map = @am.word_pair_map
     assert_equal(1,word_pair_map.size)
     assert_equal(word_pair_map. keys.first.source, "(x)(\\S+)(y)")
   end
 
   def test_add_html_tag
     @am.add_html("Test", :TEST)
-    tags = @klass::HTML_TAGS
+    tags = @am.html_tags
     assert_equal(6, tags.size)
     assert(tags.has_key?("test"))
   end
 
   def test_add_special
     @am.add_special("WikiWord", :WIKIWORD)
-    specials = @klass::SPECIAL
+    specials = @am.special
     assert_equal(1,specials.size)
     assert(specials.has_key?("WikiWord"))
   end
@@ -73,4 +67,3 @@ class TestAttributeManager < MiniTest::Unit::TestCase
 
 end
 
-MiniTest::Unit.autorun

data/test/test_rdoc_any_method.rb

@@ -6,5 +6,28 @@ class RDocAnyMethodTest < XrefTestCase
     assert_equal 'C1::m', @c1.method_list.first.full_name
   end
 
+  def test_parent_name
+    assert_equal 'C1', @c1.method_list.first.parent_name
+    assert_equal 'C1', @c1.method_list.last.parent_name
+  end
+
+  def test_marshal_load
+    instance_method = Marshal.load Marshal.dump(@c1.method_list.last)
+
+    assert_equal 'C1#m', instance_method.full_name
+    assert_equal 'C1',   instance_method.parent_name
+
+    class_method = Marshal.load Marshal.dump(@c1.method_list.first)
+
+    assert_equal 'C1::m', class_method.full_name
+    assert_equal 'C1',    class_method.parent_name
+  end
+
+  def test_name
+    m = RDoc::AnyMethod.new nil, nil
+
+    assert_nil m.name
+  end
+
 end
 

data/test/test_rdoc_attr.rb

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'minitest/autorun'
+require 'rdoc/rdoc'
+
+class TestRDocAttr < MiniTest::Unit::TestCase
+
+  def setup
+    @a = RDoc::Attr.new nil, 'attr', 'RW', ''
+  end
+
+  def test_block_params
+    assert_nil @a.block_params
+  end
+
+  def test_call_seq
+    assert_nil @a.call_seq
+  end
+
+  def test_full_name
+    assert_equal '(unknown)#attr', @a.full_name
+  end
+
+  def test_singleton
+    refute @a.singleton
+  end
+
+  def test_type
+    assert_equal 'attr_accessor', @a.type
+
+    @a.rw = 'R'
+
+    assert_equal 'attr_reader', @a.type
+
+    @a.rw = 'W'
+
+    assert_equal 'attr_writer', @a.type
+  end
+
+end
+

data/test/test_rdoc_class_module.rb

@@ -0,0 +1,100 @@
+require 'test/xref_test_case'
+
+class TestRDocClassModule < XrefTestCase
+
+  def setup
+    super
+
+    @RM = RDoc::Markup
+  end
+
+  def test_comment_equals
+    cm = RDoc::ClassModule.new 'Klass'
+    cm.comment = '# comment 1'
+
+    assert_equal 'comment 1', cm.comment
+
+    cm.comment = '# comment 2'
+
+    assert_equal "comment 1\n---\ncomment 2", cm.comment
+
+    cm.comment = "# * comment 3"
+
+    assert_equal "comment 1\n---\ncomment 2\n---\n* comment 3", cm.comment
+  end
+
+  # handle making a short module alias of yourself
+
+  def test_find_class_named
+    @c2.classes_hash['C2'] = @c2
+
+    assert_nil @c2.find_class_named('C1')
+  end
+
+  def test_merge
+    cm1 = RDoc::ClassModule.new 'Klass'
+    cm1.comment = 'klass 1'
+    cm1.add_attribute RDoc::Attr.new(nil, 'a1', 'RW', '')
+    cm1.add_attribute RDoc::Attr.new(nil, 'a3', 'R', '')
+    cm1.add_constant RDoc::Constant.new('C1', nil, '')
+    cm1.add_include RDoc::Include.new('I1', '')
+    cm1.add_method RDoc::AnyMethod.new(nil, 'm1')
+
+    cm2 = RDoc::ClassModule.new 'Klass'
+    cm2.instance_variable_set(:@comment,
+                              @RM::Document.new(
+                                @RM::Paragraph.new('klass 2')))
+    cm2.add_attribute RDoc::Attr.new(nil, 'a2', 'RW', '')
+    cm2.add_attribute RDoc::Attr.new(nil, 'a3', 'W', '')
+    cm2.add_constant RDoc::Constant.new('C2', nil, '')
+    cm2.add_include RDoc::Include.new('I2', '')
+    cm2.add_method RDoc::AnyMethod.new(nil, 'm2')
+
+    cm1.merge cm2
+
+    document = @RM::Document.new(
+      @RM::Paragraph.new('klass 2'),
+      @RM::Paragraph.new('klass 1'))
+
+    assert_equal document, cm1.comment
+
+    expected = [
+      RDoc::Attr.new(nil, 'a1', 'RW', ''),
+      RDoc::Attr.new(nil, 'a2', 'RW', ''),
+      RDoc::Attr.new(nil, 'a3', 'RW', ''),
+    ]
+
+    expected.each do |a| a.parent = cm1 end
+    assert_equal expected, cm1.attributes.sort
+
+    expected = [
+      RDoc::Constant.new('C1', nil, ''),
+      RDoc::Constant.new('C2', nil, ''),
+    ]
+
+    expected.each do |c| c.parent = cm1 end
+    assert_equal expected, cm1.constants.sort
+
+    expected = [
+      RDoc::Include.new('I1', ''),
+      RDoc::Include.new('I2', ''),
+    ]
+
+    expected.each do |i| i.parent = cm1 end
+    assert_equal expected, cm1.includes.sort
+
+    expected = [
+      RDoc::AnyMethod.new(nil, 'm1'),
+      RDoc::AnyMethod.new(nil, 'm2'),
+    ]
+
+    expected.each do |m| m.parent = cm1 end
+    assert_equal expected, cm1.method_list.sort
+  end
+
+  def test_superclass
+    assert_equal @c3_h1, @c3_h2.superclass
+  end
+
+end
+

data/test/test_rdoc_code_object.rb

@@ -16,13 +16,13 @@ class TestRDocCodeObject < XrefTestCase
     assert @co.document_children, 'document_children'
     refute @co.force_documentation, 'force_documentation'
     refute @co.done_documenting, 'done_documenting'
-    assert_equal nil, @co.comment, 'comment is nil'
+    assert_equal '', @co.comment, 'comment is empty'
   end
 
   def test_comment_equals
     @co.comment = ''
 
-    assert_equal nil, @co.comment
+    assert_equal '', @co.comment
 
     @co.comment = 'I am a comment'
 
@@ -45,6 +45,22 @@ class TestRDocCodeObject < XrefTestCase
     assert_empty @c1.method_list
   end
 
+  def test_documented_eh
+    refute @co.documented?
+
+    @co.comment = 'hi'
+
+    assert @co.documented?
+
+    @co.comment.replace ''
+
+    refute @co.documented?
+
+    @co.document_self = false
+
+    assert @co.documented?
+  end
+
   def test_parent_file_name
     assert_equal '(unknown)', @co.parent_file_name
     assert_equal 'xref_data.rb', @c1.parent_file_name

data/test/test_rdoc_context.rb

@@ -51,6 +51,28 @@ class TestRDocContext < XrefTestCase
     assert_equal %w[old_name new_name], @context.method_list.map { |m| m.name }
   end
 
+  def test_add_alias_impl
+    meth = RDoc::AnyMethod.new nil, 'old_name'
+    meth.comment    = 'old comment'
+    meth.singleton  = false
+    meth.visibility = :private
+
+    alas = RDoc::Alias.new nil, 'old_name', 'new_name', 'new comment'
+
+    @context.add_alias_impl alas, meth
+
+    assert_equal 1, @context.method_list.length
+
+    alas_meth = @context.method_list.first
+    assert_equal 'new_name',    alas_meth.name
+    assert_equal 'new comment', alas_meth.comment
+    assert_equal false,         alas_meth.singleton
+    assert_equal meth,          alas_meth.is_alias_for
+    assert_equal :private,      alas_meth.visibility
+
+    assert_equal [alas_meth], meth.aliases
+  end
+
   def test_add_class
     @c1.add_class RDoc::NormalClass, 'Klass', 'Object'
 
@@ -58,6 +80,15 @@ class TestRDocContext < XrefTestCase
     assert_includes RDoc::TopLevel.classes.map { |k| k.full_name }, 'C1::Klass'
   end
 
+  def test_add_class_superclass
+    @c1.add_class RDoc::NormalClass, 'Klass', 'Object'
+    @c1.add_class RDoc::NormalClass, 'Klass', 'Other'
+    @c1.add_class RDoc::NormalClass, 'Klass', 'Object'
+
+    klass = @c1.find_module_named 'Klass'
+    assert_equal 'Other', klass.superclass
+  end
+
   def test_add_class_upgrade
     @c1.add_module RDoc::NormalModule, 'Klass'
     @c1.add_class RDoc::NormalClass, 'Klass', nil
@@ -117,6 +148,12 @@ class TestRDocContext < XrefTestCase
     assert_includes @c1.modules.map { |m| m.full_name }, 'C1::Mod'
   end
 
+  def test_add_module_alias
+    c3_c4 = @c2.add_module_alias @c2_c3, 'C4'
+
+    assert_equal @c2.find_module_named('C4'), c3_c4
+  end
+
   def test_add_module_class
     k = @c1.add_class RDoc::NormalClass, 'Klass', nil
     m = @c1.add_module RDoc::NormalModule, 'Klass'
@@ -161,6 +198,10 @@ class TestRDocContext < XrefTestCase
     refute_includes arr, incl
   end
 
+  def test_child_name
+    assert_equal 'C1::C1', @c1.child_name('C1')
+  end
+
   def test_classes
     assert_equal %w[C2::C3], @c2.classes.map { |k| k.full_name }
     assert_equal %w[C3::H1 C3::H2], @c3.classes.map { |k| k.full_name }

data/test/test_rdoc_generator_ri.rb

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'minitest/autorun'
+require 'rdoc/rdoc'
+require 'tmpdir'
+require 'fileutils'
+
+class TestRDocGeneratorRI < MiniTest::Unit::TestCase
+
+  def setup
+    @pwd = Dir.pwd
+    RDoc::TopLevel.reset
+
+    @tmpdir = File.join Dir.tmpdir, "test_rdoc_generator_ri_#{$$}"
+    FileUtils.mkdir_p @tmpdir
+    Dir.chdir @tmpdir
+    options = RDoc::Options.new
+
+    @g = RDoc::Generator::RI.new options
+
+    @top_level = RDoc::TopLevel.new 'file.rb'
+    @klass = @top_level.add_class RDoc::NormalClass, 'Object'
+    @meth = RDoc::AnyMethod.new nil, 'method'
+    @meth_bang = RDoc::AnyMethod.new nil, 'method!'
+    @attr = RDoc::Attr.new nil, 'attr', 'RW', ''
+
+    @klass.add_method @meth
+    @klass.add_method @meth_bang
+    @klass.add_attribute @attr
+  end
+
+  def teardown
+    Dir.chdir @pwd
+    FileUtils.rm_rf @tmpdir
+  end
+
+  def assert_file path
+    assert File.file?(path), "#{path} is not a file"
+  end
+
+  def test_generate
+    top_level = RDoc::TopLevel.new 'file.rb'
+    top_level.add_class @klass.class, @klass.name
+
+    @g.generate nil
+
+    assert_file File.join(@tmpdir, 'cache.ri')
+
+    assert_file File.join(@tmpdir, 'Object', 'cdesc-Object.ri')
+
+    assert_file File.join(@tmpdir, 'Object', 'attr-i.ri')
+    assert_file File.join(@tmpdir, 'Object', 'method-i.ri')
+    assert_file File.join(@tmpdir, 'Object', 'method%21-i.ri')
+  end
+
+end
+

data/test/test_rdoc_markup.rb

@@ -1,626 +1,37 @@
 require 'rubygems'
-require 'minitest/unit'
+require 'minitest/autorun'
 require 'rdoc/markup'
 require 'rdoc/markup/to_test'
 
 class TestRDocMarkup < MiniTest::Unit::TestCase
 
-  def basic_conv(str)
-    sm = RDoc::Markup.new
-    mock = RDoc::Markup::ToTest.new
-    sm.convert(str, mock)
-    sm.content
-  end
-
-  def line_groups(str, expected)
-    m = RDoc::Markup.new
-    mock = RDoc::Markup::ToTest.new
-
-    block = m.convert(str, mock)
+  def test_convert
+    str = <<-STR
+now is
+the time
 
-    unless block == expected then
-      rows = (0...([expected.size, block.size].max)).collect{|i|
-        [expected[i]||"nil", block[i]||"nil"]
-      }
-      printf "\n\n%35s %35s\n", "Expected", "Got"
-      rows.each { |e,g| printf "%35s %35s\n", e.dump, g.dump }
-    end
+  hello
+  dave
 
-    assert_equal(expected, block)
-  end
+1. l1
+2. l2
+    STR
 
-  def line_types(str, expected)
     m = RDoc::Markup.new
-    mock = RDoc::Markup::ToTest.new
-    m.convert(str, mock)
-    assert_equal(expected, m.get_line_types.map{|type| type.to_s[0,1]}.join(''))
-  end
-
-  def test_groups
-    str = "now is the time"
-    line_groups(str, ["L0: Paragraph\nnow is the time"] )
-
-    str = "now is the time\nfor all good men"
-    line_groups(str, ["L0: Paragraph\nnow is the time for all good men"] )
-
-    str = %{\
-      now is the time
-        code _line_ here
-      for all good men}
-
-    line_groups(str,
-                [ "L0: Paragraph\nnow is the time",
-                  "L0: Verbatim\n  code _line_ here\n",
-                  "L0: Paragraph\nfor all good men"
-                ] )
-
-    str = "now is the time\n  code\n more code\nfor all good men"
-    line_groups(str,
-                [ "L0: Paragraph\nnow is the time",
-                  "L0: Verbatim\n  code\n more code\n",
-                  "L0: Paragraph\nfor all good men"
-                ] )
-
-    str = %{\
-       now is
-       * l1
-       * l2
-       the time}
-    line_groups(str,
-                [ "L0: Paragraph\nnow is",
-                  "L1: ListStart\n",
-                  "L1: BULLET ListItem\nl1",
-                  "L1: BULLET ListItem\nl2",
-                  "L1: ListEnd\n",
-                  "L0: Paragraph\nthe time"
-                ])
-
-    str = %{\
-       now is
-       * l1
-         l1+
-       * l2
-       the time}
-    line_groups(str,
-                [ "L0: Paragraph\nnow is",
-                  "L1: ListStart\n",
-                  "L1: BULLET ListItem\nl1 l1+",
-                  "L1: BULLET ListItem\nl2",
-                  "L1: ListEnd\n",
-                  "L0: Paragraph\nthe time"
-                ])
-
-    str = %{\
-       now is
-       * l1
-         * l1.1
-       * l2
-       the time}
-    line_groups(str,
-                [ "L0: Paragraph\nnow is",
-                  "L1: ListStart\n",
-                  "L1: BULLET ListItem\nl1",
-                  "L2: ListStart\n",
-                  "L2: BULLET ListItem\nl1.1",
-                  "L2: ListEnd\n",
-                  "L1: BULLET ListItem\nl2",
-                  "L1: ListEnd\n",
-                  "L0: Paragraph\nthe time"
-                ])
-
-
-    str = %{\
-       now is
-       * l1
-         * l1.1
-           text
-             code
-               code
-
-           text
-       * l2
-       the time}
-    line_groups(str,
-                [ "L0: Paragraph\nnow is",
-                  "L1: ListStart\n",
-                  "L1: BULLET ListItem\nl1",
-                  "L2: ListStart\n",
-                  "L2: BULLET ListItem\nl1.1 text",
-                  "L2: Verbatim\n  code\n    code\n",
-                  "L2: Paragraph\ntext",
-                  "L2: ListEnd\n",
-                  "L1: BULLET ListItem\nl2",
-                  "L1: ListEnd\n",
-                  "L0: Paragraph\nthe time"
-                ])
-
-
-    str = %{\
-       now is
-       1. l1
-          * l1.1
-       2. l2
-       the time}
-    line_groups(str,
-                [ "L0: Paragraph\nnow is",
-                  "L1: ListStart\n",
-                  "L1: NUMBER ListItem\nl1",
-                  "L2: ListStart\n",
-                  "L2: BULLET ListItem\nl1.1",
-                  "L2: ListEnd\n",
-                  "L1: NUMBER ListItem\nl2",
-                  "L1: ListEnd\n",
-                  "L0: Paragraph\nthe time"
-                ])
-
-    str = %{\
-       now is
-       [cat] l1
-             * l1.1
-       [dog] l2
-       the time}
-    line_groups(str,
-                [ "L0: Paragraph\nnow is",
-                  "L1: ListStart\n",
-                  "L1: LABELED ListItem\ncat: l1",
-                  "L2: ListStart\n",
-                  "L2: BULLET ListItem\nl1.1",
-                  "L2: ListEnd\n",
-                  "L1: LABELED ListItem\ndog: l2",
-                  "L1: ListEnd\n",
-                  "L0: Paragraph\nthe time"
-                ])
-
-    str = %{\
-       now is
-       [cat] l1
-             continuation
-       [dog] l2
-       the time}
-    line_groups(str,
-                [ "L0: Paragraph\nnow is",
-                  "L1: ListStart\n",
-                  "L1: LABELED ListItem\ncat: l1 continuation",
-                  "L1: LABELED ListItem\ndog: l2",
-                  "L1: ListEnd\n",
-                  "L0: Paragraph\nthe time"
-                ])
-  end
-
-  def test_headings
-    str = "= heading one"
-    line_groups(str,
-                [ "L0: Heading\nheading one"
-                ])
-
-    str = "=== heading three"
-    line_groups(str,
-                [ "L0: Heading\nheading three"
-                ])
-
-    str = "text\n   === heading three"
-    line_groups(str,
-                [ "L0: Paragraph\ntext",
-                  "L0: Verbatim\n   === heading three\n"
-                ])
-
-    str = "text\n   code\n   === heading three"
-    line_groups(str,
-                [ "L0: Paragraph\ntext",
-                  "L0: Verbatim\n   code\n   === heading three\n"
-                ])
-
-    str = "text\n   code\n=== heading three"
-    line_groups(str,
-                [ "L0: Paragraph\ntext",
-                  "L0: Verbatim\n   code\n",
-                  "L0: Heading\nheading three"
-                ])
-
-  end
-
-  def test_list_alpha
-    str = "a. alpha\nb. baker\nB. ALPHA\nA. BAKER"
-
-    line_groups(str,
-                [ "L1: ListStart\n",
-                  "L1: LOWERALPHA ListItem\nalpha",
-                  "L1: LOWERALPHA ListItem\nbaker",
-                  "L1: ListEnd\n",
-                  "L1: ListStart\n",
-                  "L1: UPPERALPHA ListItem\nALPHA",
-                  "L1: UPPERALPHA ListItem\nBAKER",
-                  "L1: ListEnd\n" ])
-  end
-
-  def test_list_bullet_dash
-    str = "- one\n- two\n"
-
-    line_groups(str,
-                [ "L1: ListStart\n",
-                  "L1: BULLET ListItem\none",
-                  "L1: BULLET ListItem\ntwo",
-                  "L1: ListEnd\n" ])
-  end
-
-  def test_list_bullet_star
-    str = "* one\n* two\n"
-
-    line_groups(str,
-                [ "L1: ListStart\n",
-                  "L1: BULLET ListItem\none",
-                  "L1: BULLET ListItem\ntwo",
-                  "L1: ListEnd\n" ])
-  end
-
-  def test_list_labeled_bracket
-    str = "[one] item one\n[two] item two"
-
-    line_groups(str,
-                [ "L1: ListStart\n",
-                  "L1: LABELED ListItem\none: item one",
-                  "L1: LABELED ListItem\ntwo: item two",
-                  "L1: ListEnd\n" ])
-  end
-
-  def test_list_labeled_bracket_continued
-    str = "[one]\n  item one\n[two]\n  item two"
-
-    line_groups(str,
-                [ "L1: ListStart\n",
-                  "L1: LABELED ListItem\none: item one",
-                  "L1: LABELED ListItem\ntwo: item two",
-                  "L1: ListEnd\n" ])
-  end
-
-  def test_list_labeled_colon
-    str = "one:: item one\ntwo:: item two"
-
-    line_groups(str,
-                [ "L1: ListStart\n",
-                  "L1: NOTE ListItem\none:: item one",
-                  "L1: NOTE ListItem\ntwo:: item two",
-                  "L1: ListEnd\n" ])
-  end
-
-  def test_list_labeled_colon_continued
-    str = "one::\n  item one\ntwo::\n  item two"
-
-    line_groups(str,
-                [ "L1: ListStart\n",
-                  "L1: NOTE ListItem\none:: item one",
-                  "L1: NOTE ListItem\ntwo:: item two",
-                  "L1: ListEnd\n" ])
-  end
-
-  def test_list_nested_bullet_bullet
-    str = "* one\n* two\n  * cat\n  * dog"
-
-    line_groups(str,
-                [ "L1: ListStart\n",
-                  "L1: BULLET ListItem\none",
-                  "L1: BULLET ListItem\ntwo",
-                  "L2: ListStart\n",
-                  "L2: BULLET ListItem\ncat",
-                  "L2: BULLET ListItem\ndog",
-                  "L2: ListEnd\n",
-                  "L1: ListEnd\n" ])
-  end
-
-  def test_list_nested_labeled_bullet
-    str = "[one]\n  * cat\n  * dog"
-
-    line_groups(str,
-                [ "L1: ListStart\n",
-                  "L1: LABELED ListItem\none: ",
-                  "L2: ListStart\n",
-                  "L2: BULLET ListItem\ncat",
-                  "L2: BULLET ListItem\ndog",
-                  "L2: ListEnd\n",
-                  "L1: ListEnd\n" ])
-  end
-
-  def test_list_nested_labeled_bullet_bullet
-    str = "[one]\n  * cat\n    * dog"
-
-    line_groups(str,
-                [ "L1: ListStart\n",
-                  "L1: LABELED ListItem\none: ",
-                  "L2: ListStart\n",
-                  "L2: BULLET ListItem\ncat",
-                  "L3: ListStart\n",
-                  "L3: BULLET ListItem\ndog",
-                  "L3: ListEnd\n",
-                  "L2: ListEnd\n",
-                  "L1: ListEnd\n" ])
-  end
-
-  def test_list_nested_number_number
-    str = "1. one\n1. two\n   1. cat\n   1. dog"
-
-    line_groups(str,
-                [ "L1: ListStart\n",
-                  "L1: NUMBER ListItem\none",
-                  "L1: NUMBER ListItem\ntwo",
-                  "L2: ListStart\n",
-                  "L2: NUMBER ListItem\ncat",
-                  "L2: NUMBER ListItem\ndog",
-                  "L2: ListEnd\n",
-                  "L1: ListEnd\n" ])
-  end
-
-  def test_list_number
-    str = "1. one\n2. two\n1. three"
-
-    line_groups(str,
-                [ "L1: ListStart\n",
-                  "L1: NUMBER ListItem\none",
-                  "L1: NUMBER ListItem\ntwo",
-                  "L1: NUMBER ListItem\nthree",
-                  "L1: ListEnd\n" ])
-  end
-
-  def test_list_split
-    str = %{\
-       now is
-       * l1
-       1. n1
-       2. n2
-       * l2
-       the time}
-    line_groups(str,
-                [ "L0: Paragraph\nnow is",
-                  "L1: ListStart\n",
-                  "L1: BULLET ListItem\nl1",
-                  "L1: ListEnd\n",
-                  "L1: ListStart\n",
-                  "L1: NUMBER ListItem\nn1",
-                  "L1: NUMBER ListItem\nn2",
-                  "L1: ListEnd\n",
-                  "L1: ListStart\n",
-                  "L1: BULLET ListItem\nl2",
-                  "L1: ListEnd\n",
-                  "L0: Paragraph\nthe time"
-                ])
-
-  end
-
-  def test_list_verbatim
-    str = "* one\n    verb1\n    verb2\n* two\n"
-
-    line_groups(str,
-                [ "L1: ListStart\n",
-                  "L1: BULLET ListItem\none",
-                  "L1: Verbatim\n  verb1\n  verb2\n",
-                  "L1: BULLET ListItem\ntwo",
-                  "L1: ListEnd\n" ])
-  end
-
-  def test_paragraph
-    str = "paragraph\n\n*bold* paragraph\n"
-
-    line_groups str, [
-      "L0: Paragraph\nparagraph",
-      "L0: BlankLine\n",
-      "L0: Paragraph\n*bold* paragraph"
+    out = m.convert str, RDoc::Markup::ToTest.new
+
+    expected = [
+      "now is the time",
+      "\n",
+      "  hello\n  dave\n",
+      "1: ",
+      "l1",
+      "1: ",
+      "l2",
     ]
-  end
-
-  def test_tabs
-    str = "hello\n  dave"
-    assert_equal(str, basic_conv(str))
-    str = "hello\n\tdave"
-    assert_equal("hello\n        dave", basic_conv(str))
-    str = "hello\n \tdave"
-    assert_equal("hello\n        dave", basic_conv(str))
-    str = "hello\n  \tdave"
-    assert_equal("hello\n        dave", basic_conv(str))
-    str = "hello\n   \tdave"
-    assert_equal("hello\n        dave", basic_conv(str))
-    str = "hello\n    \tdave"
-    assert_equal("hello\n        dave", basic_conv(str))
-    str = "hello\n     \tdave"
-    assert_equal("hello\n        dave", basic_conv(str))
-    str = "hello\n      \tdave"
-    assert_equal("hello\n        dave", basic_conv(str))
-    str = "hello\n       \tdave"
-    assert_equal("hello\n        dave", basic_conv(str))
-    str = "hello\n        \tdave"
-    assert_equal("hello\n                dave", basic_conv(str))
-    str = ".\t\t."
-    assert_equal(".               .", basic_conv(str))
-  end
-
-  def test_types
-    str = "now is the time"
-    line_types(str, 'P')
-
-    str = "now is the time\nfor all good men"
-    line_types(str, 'PP')
-
-    str = "now is the time\n  code\nfor all good men"
-    line_types(str, 'PVP')
-
-    str = "now is the time\n  code\n more code\nfor all good men"
-    line_types(str, 'PVVP')
-
-    str = "now is\n---\nthe time"
-    line_types(str, 'PRP')
-
-    str = %{\
-       now is
-       * l1
-       * l2
-       the time}
-    line_types(str, 'PLLP')
-
-    str = %{\
-       now is
-       * l1
-         l1+
-       * l2
-       the time}
-    line_types(str, 'PLPLP')
-
-    str = %{\
-       now is
-       * l1
-         * l1.1
-       * l2
-       the time}
-    line_types(str, 'PLLLP')
-
-    str = %{\
-       now is
-       * l1
-         * l1.1
-           text
-             code
-             code
-
-           text
-       * l2
-       the time}
-    line_types(str, 'PLLPVVBPLP')
-
-    str = %{\
-       now is
-       1. l1
-          * l1.1
-       2. l2
-       the time}
-    line_types(str, 'PLLLP')
-
-    str = %{\
-       now is
-       [cat] l1
-             * l1.1
-       [dog] l2
-       the time}
-    line_types(str, 'PLLLP')
-
-    str = %{\
-       now is
-       [cat] l1
-             continuation
-       [dog] l2
-       the time}
-    line_types(str, 'PLPLP')
-  end
-
-  def test_verbatim
-    str = "paragraph\n  *bold* verbatim\n"
-
-    line_groups str, [
-      "L0: Paragraph\nparagraph",
-      "L0: Verbatim\n  *bold* verbatim\n"
-    ]
-  end
-
-  def test_verbatim_merge
-    str = %{\
-       now is
-          code
-       the time}
-
-    line_groups(str,
-                [ "L0: Paragraph\nnow is",
-                  "L0: Verbatim\n   code\n",
-                  "L0: Paragraph\nthe time"
-                ])
-
-
-    str = %{\
-       now is
-          code
-          code1
-       the time}
-
-    line_groups(str,
-                [ "L0: Paragraph\nnow is",
-                  "L0: Verbatim\n   code\n   code1\n",
-                  "L0: Paragraph\nthe time"
-                ])
-
-
-    str = %{\
-       now is
-          code
-
-          code1
-       the time}
-
-    line_groups(str,
-                [ "L0: Paragraph\nnow is",
-                  "L0: Verbatim\n   code\n\n   code1\n",
-                  "L0: Paragraph\nthe time"
-                ])
-
-
-    str = %{\
-       now is
-          code
-
-          code1
-
-       the time}
-
-    line_groups(str,
-                [ "L0: Paragraph\nnow is",
-                  "L0: Verbatim\n   code\n\n   code1\n",
-                  "L0: Paragraph\nthe time"
-                ])
-
-
-    str = %{\
-       now is
-          code
-
-          code1
-
-          code2
-       the time}
-
-    line_groups(str,
-                [ "L0: Paragraph\nnow is",
-                  "L0: Verbatim\n   code\n\n   code1\n\n   code2\n",
-                  "L0: Paragraph\nthe time"
-                ])
-
-
-    # Folds multiple blank lines
-    str = %{\
-       now is
-          code
-
-
-          code1
-
-       the time}
-
-    line_groups(str,
-                [ "L0: Paragraph\nnow is",
-                  "L0: Verbatim\n   code\n\n   code1\n",
-                  "L0: Paragraph\nthe time"
-                ])
-
-
-  end
-
-  def test_whitespace
-    assert_equal("hello", basic_conv("hello"))
-    assert_equal("hello", basic_conv(" hello "))
-    assert_equal("hello", basic_conv(" \t \t hello\t\t"))
-
-    assert_equal("1\n 2\n  3", basic_conv("1\n 2\n  3"))
-    assert_equal("1\n 2\n  3", basic_conv("  1\n   2\n    3"))
-
-    assert_equal("1\n 2\n  3\n1\n 2", basic_conv("1\n 2\n  3\n1\n 2"))
-    assert_equal("1\n 2\n  3\n1\n 2", basic_conv("  1\n   2\n    3\n  1\n   2"))
 
-    assert_equal("1\n 2\n\n  3", basic_conv("  1\n   2\n\n    3"))
+    assert_equal expected, out
   end
 
 end
 
-MiniTest::Unit.autorun