horseman 0.0.2 → 0.0.3

data/vendor/ruby/1.9.1/gems/rdoc-3.12/test/test_rdoc_ri_driver.rb

@@ -0,0 +1,1059 @@
+require 'rdoc/test_case'
+
+class TestRDocRIDriver < RDoc::TestCase
+
+  def setup
+    super
+
+    @tmpdir = File.join Dir.tmpdir, "test_rdoc_ri_driver_#{$$}"
+    @home_ri = File.join @tmpdir, 'dot_ri'
+
+    FileUtils.mkdir_p @tmpdir
+    FileUtils.mkdir_p @home_ri
+
+    @orig_ri = ENV['RI']
+    @orig_home = ENV['HOME']
+    ENV['HOME'] = @tmpdir
+    ENV.delete 'RI'
+
+    @options = RDoc::RI::Driver.process_args []
+    @options[:home] = @tmpdir
+    @options[:use_stdout] = true
+    @options[:formatter] = @RM::ToRdoc
+    @driver = RDoc::RI::Driver.new @options
+  end
+
+  def teardown
+    super
+
+    ENV['HOME'] = @orig_home
+    ENV['RI'] = @orig_ri
+    FileUtils.rm_rf @tmpdir
+  end
+
+  DUMMY_PAGER = ":;\n"
+
+  def with_dummy_pager
+    pager_env, ENV['RI_PAGER'] = ENV['RI_PAGER'], DUMMY_PAGER
+    yield
+  ensure
+    ENV['RI_PAGER'] = pager_env
+  end
+
+  def mu_pp(obj)
+    s = ''
+    s = PP.pp obj, s
+    s = s.force_encoding(Encoding.default_external) if defined? Encoding
+    s.chomp
+  end
+
+  def test_self_dump
+    util_store
+
+    out, = capture_io do
+      RDoc::RI::Driver.dump @store.cache_path
+    end
+
+    assert_match %r%:class_methods%,    out
+    assert_match %r%:modules%,          out
+    assert_match %r%:instance_methods%, out
+    assert_match %r%:ancestors%,        out
+  end
+
+  def test_add_also_in_empty
+    out = @RM::Document.new
+
+    @driver.add_also_in out, []
+
+    assert_empty out
+  end
+
+  def test_add_also_in
+    util_multi_store
+    @store1.type = :system
+    @store2.type = :home
+
+    out = @RM::Document.new
+
+    @driver.add_also_in out, [@store1, @store2]
+
+    expected = @RM::Document.new(
+      @RM::Rule.new(1),
+      @RM::Paragraph.new('Also found in:'),
+      @RM::Verbatim.new("ruby core", "\n",
+                        "~/.ri", "\n"))
+
+    assert_equal expected, out
+  end
+
+  def test_add_class
+    util_multi_store
+
+    out = @RM::Document.new
+
+    @driver.add_class out, 'Bar', [@cBar]
+
+    expected = @RM::Document.new(
+      @RM::Heading.new(1, 'Bar < Foo'),
+      @RM::BlankLine.new)
+
+    assert_equal expected, out
+  end
+
+  def test_add_from
+    util_store
+    @store.type = :system
+
+    out = @RM::Document.new
+
+    @driver.add_from out, @store
+
+    expected = @RM::Document.new @RM::Paragraph.new("(from ruby core)")
+
+    assert_equal expected, out
+  end
+
+  def test_add_includes_empty
+    out = @RM::Document.new
+
+    @driver.add_includes out, []
+
+    assert_empty out
+  end
+
+  def test_add_includes_many
+    util_store
+
+    out = @RM::Document.new
+
+    enum = RDoc::Include.new 'Enumerable', nil
+    @cFoo.add_include enum
+
+    @driver.add_includes out, [[[@cFooInc, enum], @store]]
+
+    expected = @RM::Document.new(
+      @RM::Rule.new(1),
+      @RM::Heading.new(1, "Includes:"),
+      @RM::Paragraph.new("(from #{@store.friendly_path})"),
+      @RM::BlankLine.new,
+      @RM::Paragraph.new("Inc"),
+      @RM::BlankLine.new,
+      @RM::Paragraph.new("Include thingy"),
+      @RM::BlankLine.new,
+      @RM::Verbatim.new("Enumerable", "\n"))
+
+    assert_equal expected, out
+  end
+
+  def test_add_includes_many_no_doc
+    util_store
+
+    out = @RM::Document.new
+
+    enum = RDoc::Include.new 'Enumerable', nil
+    @cFoo.add_include enum
+    @cFooInc.instance_variable_set :@comment, ''
+
+    @driver.add_includes out, [[[@cFooInc, enum], @store]]
+
+    expected = @RM::Document.new(
+      @RM::Rule.new(1),
+      @RM::Heading.new(1, "Includes:"),
+      @RM::Paragraph.new("(from #{@store.friendly_path})"),
+      @RM::Verbatim.new("Inc", "\n",
+                        "Enumerable", "\n"))
+
+    assert_equal expected, out
+  end
+
+  def test_add_includes_one
+    util_store
+
+    out = @RM::Document.new
+
+    @driver.add_includes out, [[[@cFooInc], @store]]
+
+    expected = @RM::Document.new(
+      @RM::Rule.new(1),
+      @RM::Heading.new(1, "Includes:"),
+      @RM::Paragraph.new("Inc (from #{@store.friendly_path})"),
+      @RM::BlankLine.new,
+      @RM::Paragraph.new("Include thingy"),
+      @RM::BlankLine.new)
+
+    assert_equal expected, out
+  end
+
+  def test_add_method_list
+    out = @RM::Document.new
+
+    @driver.add_method_list out, %w[new parse], 'Class methods'
+
+    expected = @RM::Document.new(
+      @RM::Heading.new(1, 'Class methods:'),
+      @RM::BlankLine.new,
+      @RM::Verbatim.new('new'),
+      @RM::Verbatim.new('parse'),
+      @RM::BlankLine.new)
+
+    assert_equal expected, out
+  end
+
+  def test_add_method_list_interative
+    @options[:interactive] = true
+    driver = RDoc::RI::Driver.new @options
+
+    out = @RM::Document.new
+
+    driver.add_method_list out, %w[new parse], 'Class methods'
+
+    expected = @RM::Document.new(
+      @RM::Heading.new(1, 'Class methods:'),
+      @RM::BlankLine.new,
+      @RM::IndentedParagraph.new(2, 'new, parse'),
+      @RM::BlankLine.new)
+
+    assert_equal expected, out
+  end
+
+  def test_add_method_list_none
+    out = @RM::Document.new
+
+    @driver.add_method_list out, [], 'Class'
+
+    assert_equal @RM::Document.new, out
+  end
+
+  def test_ancestors_of
+    util_ancestors_store
+
+    assert_equal %w[X Mixin Object Foo], @driver.ancestors_of('Foo::Bar')
+  end
+
+  def test_classes
+    util_multi_store
+
+    expected = {
+      'Ambiguous' => [@store1, @store2],
+      'Bar'       => [@store2],
+      'Foo'       => [@store1],
+      'Foo::Bar'  => [@store1],
+      'Foo::Baz'  => [@store1, @store2],
+      'Inc'       => [@store1],
+    }
+
+    assert_equal expected, @driver.classes
+  end
+
+  def test_class_document
+    util_store
+
+    tl1 = RDoc::TopLevel.new 'one.rb'
+    tl2 = RDoc::TopLevel.new 'two.rb'
+
+    @cFoo.add_comment 'one', tl1
+    @cFoo.add_comment 'two', tl2
+    @store.save_class @cFoo
+
+    found = [
+      [@store, @store.load_class(@cFoo.full_name)]
+    ]
+
+    out = @driver.class_document @cFoo.full_name, found, [], []
+
+    expected = @RM::Document.new
+    @driver.add_class expected, 'Foo', []
+    @driver.add_includes expected, []
+    @driver.add_from expected, @store
+    expected << @RM::Rule.new(1)
+
+    doc = @RM::Document.new(@RM::Paragraph.new('one'))
+    doc.file = 'one.rb'
+    expected.push doc
+    expected << @RM::BlankLine.new
+    doc = @RM::Document.new(@RM::Paragraph.new('two'))
+    doc.file = 'two.rb'
+    expected.push doc
+
+    expected << @RM::Rule.new(1)
+    expected << @RM::Heading.new(1, 'Instance methods:')
+    expected << @RM::BlankLine.new
+    expected << @RM::Verbatim.new('inherit')
+    expected << @RM::Verbatim.new('override')
+    expected << @RM::BlankLine.new
+
+    assert_equal expected, out
+  end
+
+  def test_complete
+    store = RDoc::RI::Store.new @home_ri
+    store.cache[:ancestors] = {
+      'Foo'      => %w[Object],
+      'Foo::Bar' => %w[Object],
+    }
+    store.cache[:class_methods] = {
+      'Foo' => %w[bar]
+    }
+    store.cache[:instance_methods] = {
+      'Foo' => %w[Bar]
+    }
+    store.cache[:modules] = %w[
+      Foo
+      Foo::Bar
+    ]
+
+    @driver.stores = [store]
+
+    assert_equal %w[Foo         ], @driver.complete('F')
+    assert_equal %w[    Foo::Bar], @driver.complete('Foo::B')
+
+    assert_equal %w[Foo#Bar],           @driver.complete('Foo#'),   'Foo#'
+    assert_equal %w[Foo#Bar  Foo::bar], @driver.complete('Foo.'),   'Foo.'
+    assert_equal %w[Foo::Bar Foo::bar], @driver.complete('Foo::'),  'Foo::'
+
+    assert_equal %w[         Foo::bar], @driver.complete('Foo::b'), 'Foo::b'
+  end
+
+  def test_complete_ancestor
+    util_ancestors_store
+
+    assert_equal %w[Foo::Bar#i_method], @driver.complete('Foo::Bar#')
+
+    assert_equal %w[Foo::Bar#i_method Foo::Bar::c_method Foo::Bar::new],
+                 @driver.complete('Foo::Bar.')
+  end
+
+  def test_complete_classes
+    util_store
+
+    assert_equal %w[                       ], @driver.complete('[')
+    assert_equal %w[                       ], @driver.complete('[::')
+    assert_equal %w[Foo                    ], @driver.complete('F')
+    assert_equal %w[Foo:: Foo::Bar Foo::Baz], @driver.complete('Foo::')
+    assert_equal %w[      Foo::Bar Foo::Baz], @driver.complete('Foo::B')
+  end
+
+  def test_complete_multistore
+    util_multi_store
+
+    assert_equal %w[Bar], @driver.complete('B')
+    assert_equal %w[Foo], @driver.complete('F')
+    assert_equal %w[Foo::Bar Foo::Baz], @driver.complete('Foo::B')
+  end
+
+  def test_display
+    doc = @RM::Document.new(
+            @RM::Paragraph.new('hi'))
+
+    out, = capture_io do
+      @driver.display doc
+    end
+
+    assert_equal "hi\n", out
+  end
+
+  def test_display_class
+    util_store
+
+    out, = capture_io do
+      @driver.display_class 'Foo::Bar'
+    end
+
+    assert_match %r%^= Foo::Bar%, out
+    assert_match %r%^\(from%, out
+
+    assert_match %r%^= Class methods:%, out
+    assert_match %r%^  new%, out
+    assert_match %r%^= Instance methods:%, out
+    assert_match %r%^  blah%, out
+    assert_match %r%^= Attributes:%, out
+    assert_match %r%^  attr_accessor attr%, out
+
+    assert_equal 1, out.scan(/-\n/).length
+  end
+
+  def test_display_class_ambiguous
+    util_multi_store
+
+    out, = capture_io do
+      @driver.display_class 'Ambiguous'
+    end
+
+    assert_match %r%^= Ambiguous < Object$%, out
+  end
+
+  def test_display_class_multi_no_doc
+    util_multi_store
+
+    out, = capture_io do
+      @driver.display_class 'Foo::Baz'
+    end
+
+    assert_match %r%^= Foo::Baz%, out
+    assert_match %r%-\n%, out
+    assert_match %r%Also found in:%, out
+    assert_match %r%#{Regexp.escape @home_ri}%, out
+    assert_match %r%#{Regexp.escape @home_ri2}%, out
+  end
+
+  def test_display_class_superclass
+    util_multi_store
+
+    out, = capture_io do
+      @driver.display_class 'Bar'
+    end
+
+    assert_match %r%^= Bar < Foo%, out
+  end
+
+  def test_display_class_module
+    util_store
+
+    out, = capture_io do
+      @driver.display_class 'Inc'
+    end
+
+    assert_match %r%^= Inc$%, out
+  end
+
+  def test_display_method
+    util_store
+
+    out, = capture_io do
+      @driver.display_method 'Foo::Bar#blah'
+    end
+
+    assert_match %r%Foo::Bar#blah%, out
+    assert_match %r%blah.5%,        out
+    assert_match %r%blah.6%,        out
+  end
+
+  def test_display_method_attribute
+    util_store
+
+    out, = capture_io do
+      @driver.display_method 'Foo::Bar#attr'
+    end
+
+    assert_match %r%Foo::Bar#attr%, out
+    refute_match %r%Implementation from%, out
+  end
+
+  def test_display_method_inherited
+    util_multi_store
+
+    out, = capture_io do
+      @driver.display_method 'Bar#inherit'
+    end
+
+    assert_match %r%^= Bar#inherit%, out
+    assert_match %r%^=== Implementation from Foo%, out
+  end
+
+  def test_display_method_overriden
+    util_multi_store
+
+    out, = capture_io do
+      @driver.display_method 'Bar#override'
+    end
+
+    refute_match %r%must not be displayed%, out
+  end
+
+  def test_display_name_not_found_class
+    util_store
+
+    out, = capture_io do
+      assert_equal false, @driver.display_name('Foo::B')
+    end
+
+    expected = <<-EXPECTED
+Foo::B not found, maybe you meant:
+
+Foo::Bar
+Foo::Baz
+    EXPECTED
+
+    assert_equal expected, out
+  end
+
+  def test_display_name_not_found_method
+    util_store
+
+    out, = capture_io do
+      assert_equal false, @driver.display_name('Foo::Bar#b')
+    end
+
+    expected = <<-EXPECTED
+Foo::Bar#b not found, maybe you meant:
+
+Foo::Bar#blah
+Foo::Bar#bother
+    EXPECTED
+
+    assert_equal expected, out
+  end
+
+  def test_display_method_params
+    util_store
+
+    out, = capture_io do
+      @driver.display_method 'Foo::Bar#bother'
+    end
+
+    assert_match %r%things.*stuff%, out
+  end
+
+  def test_expand_class
+    util_store
+
+    assert_equal 'Foo',       @driver.expand_class('F')
+    assert_equal 'Foo::Bar',  @driver.expand_class('F::Bar')
+
+    assert_raises RDoc::RI::Driver::NotFoundError do
+      @driver.expand_class 'F::B'
+    end
+  end
+
+  def test_expand_name
+    util_store
+
+    assert_equal '.b',        @driver.expand_name('b')
+    assert_equal 'Foo',       @driver.expand_name('F')
+    assert_equal 'Foo::Bar#', @driver.expand_name('F::Bar#')
+
+    e = assert_raises RDoc::RI::Driver::NotFoundError do
+      @driver.expand_name 'Z'
+    end
+
+    assert_equal 'Z', e.name
+  end
+
+  def test_find_methods
+    util_store
+
+    items = []
+
+    @driver.find_methods 'Foo::Bar.' do |store, klass, ancestor, types, method|
+      items << [store, klass, ancestor, types, method]
+    end
+
+    expected = [
+      [@store, 'Foo::Bar', 'Foo::Bar', :both, nil],
+    ]
+
+    assert_equal expected, items
+  end
+
+  def test_find_methods_method
+    util_store
+
+    items = []
+
+    @driver.find_methods '.blah' do |store, klass, ancestor, types, method|
+      items << [store, klass, ancestor, types, method]
+    end
+
+    expected = [
+      [@store, 'Ambiguous', 'Ambiguous', :both, 'blah'],
+      [@store, 'Foo',       'Foo',       :both, 'blah'],
+      [@store, 'Foo::Bar',  'Foo::Bar',  :both, 'blah'],
+      [@store, 'Foo::Baz',  'Foo::Baz',  :both, 'blah'],
+      [@store, 'Inc',       'Inc',       :both, 'blah'],
+    ]
+
+    assert_equal expected, items
+  end
+
+  def test_filter_methods
+    util_multi_store
+
+    name = 'Bar#override'
+
+    found = @driver.load_methods_matching name
+
+    sorted = @driver.filter_methods found, name
+
+    expected = [[@store2, [@override]]]
+
+    assert_equal expected, sorted
+  end
+
+  def test_filter_methods_not_found
+    util_multi_store
+
+    name = 'Bar#inherit'
+
+    found = @driver.load_methods_matching name
+
+    sorted = @driver.filter_methods found, name
+
+    assert_equal found, sorted
+  end
+
+  def test_formatter
+    tty = Object.new
+    def tty.tty?() true; end
+
+    driver = RDoc::RI::Driver.new
+
+    assert_instance_of @RM::ToAnsi, driver.formatter(tty)
+
+    assert_instance_of @RM::ToBs, driver.formatter(StringIO.new)
+
+    driver.instance_variable_set :@paging, true
+
+    assert_instance_of @RM::ToBs, driver.formatter(StringIO.new)
+
+    driver.instance_variable_set :@formatter_klass, @RM::ToHtml
+
+    assert_instance_of @RM::ToHtml, driver.formatter(tty)
+  end
+
+  def test_in_path_eh
+    path = ENV['PATH']
+
+    temp_dir do |dir|
+      nonexistent = File.join dir, 'nonexistent'
+      refute @driver.in_path?(nonexistent)
+
+      ENV['PATH'] = File.expand_path '..', __FILE__
+
+      assert @driver.in_path?(File.basename(__FILE__))
+    end
+  ensure
+    ENV['PATH'] = path
+  end
+
+  def test_method_type
+    assert_equal :both,     @driver.method_type(nil)
+    assert_equal :both,     @driver.method_type('.')
+    assert_equal :instance, @driver.method_type('#')
+    assert_equal :class,    @driver.method_type('::')
+  end
+
+  def test_name_regexp
+    assert_equal %r%^RDoc::AnyMethod#new$%,
+                 @driver.name_regexp('RDoc::AnyMethod#new')
+
+    assert_equal %r%^RDoc::AnyMethod::new$%,
+                 @driver.name_regexp('RDoc::AnyMethod::new')
+
+    assert_equal %r%^RDoc::AnyMethod(#|::)new$%,
+                 @driver.name_regexp('RDoc::AnyMethod.new')
+
+    assert_equal %r%^Hash(#|::)\[\]$%,
+                 @driver.name_regexp('Hash.[]')
+
+    assert_equal %r%^Hash::\[\]$%,
+                 @driver.name_regexp('Hash::[]')
+  end
+
+  def test_list_known_classes
+    util_store
+
+    out, = capture_io do
+      @driver.list_known_classes
+    end
+
+    assert_equal "Ambiguous\nFoo\nFoo::Bar\nFoo::Baz\nInc\n", out
+  end
+
+  def test_list_known_classes_name
+    util_store
+
+    out, = capture_io do
+      @driver.list_known_classes %w[F I]
+    end
+
+    assert_equal "Foo\nFoo::Bar\nFoo::Baz\nInc\n", out
+  end
+
+  def test_list_methods_matching
+    util_store
+
+    assert_equal %w[
+        Foo::Bar#attr
+        Foo::Bar#blah
+        Foo::Bar#bother
+        Foo::Bar::new
+      ],
+      @driver.list_methods_matching('Foo::Bar.').sort
+  end
+
+  def test_list_methods_matching_inherit
+    util_multi_store
+
+    assert_equal %w[
+        Bar#baz
+        Bar#inherit
+        Bar#override
+      ],
+      @driver.list_methods_matching('Bar.').sort
+  end
+
+  def test_list_methods_matching_regexp
+    util_store
+
+    index = RDoc::AnyMethod.new nil, '[]'
+    index.record_location @top_level
+    @cFoo.add_method index
+    @store.save_method @cFoo, index
+
+    c_index = RDoc::AnyMethod.new nil, '[]'
+    c_index.singleton = true
+    c_index.record_location @top_level
+    @cFoo.add_method c_index
+    @store.save_method @cFoo, c_index
+
+    @store.save_cache
+
+    assert_equal %w[Foo#[]], @driver.list_methods_matching('Foo#[]')
+    assert_equal %w[Foo::[]], @driver.list_methods_matching('Foo::[]')
+  end
+
+  def test_load_method
+    util_store
+
+    method = @driver.load_method(@store, :instance_methods, 'Foo', '#',
+                                 'inherit')
+
+    assert_equal @inherit, method
+  end
+
+  def test_load_method_inherited
+    util_multi_store
+
+    method = @driver.load_method(@store2, :instance_methods, 'Bar', '#',
+                                 'inherit')
+
+    assert_equal nil, method
+  end
+
+  def test_load_methods_matching
+    util_store
+
+    expected = [[@store, [@inherit]]]
+
+    assert_equal expected, @driver.load_methods_matching('Foo#inherit')
+
+    expected = [[@store, [@blah]]]
+
+    assert_equal expected, @driver.load_methods_matching('.blah')
+
+    assert_empty @driver.load_methods_matching('.b')
+  end
+
+  def test_load_methods_matching_inherited
+    util_multi_store
+
+    expected = [[@store1, [@inherit]]]
+
+    assert_equal expected, @driver.load_methods_matching('Bar#inherit')
+  end
+
+  def _test_page # this test doesn't do anything anymore :(
+    @driver.use_stdout = false
+
+    with_dummy_pager do
+      @driver.page do |io|
+        skip "couldn't find a standard pager" if io == $stdout
+
+        assert @driver.paging?
+      end
+    end
+
+    refute @driver.paging?
+  end
+
+  def test_page_stdout
+    @driver.use_stdout = true
+
+    @driver.page do |io|
+      assert_equal $stdout, io
+    end
+
+    refute @driver.paging?
+  end
+
+  def test_parse_name_method
+    klass, type, meth = @driver.parse_name 'foo'
+
+    assert_equal '',    klass, 'foo class'
+    assert_equal '.',   type,  'foo type'
+    assert_equal 'foo', meth,  'foo method'
+
+    klass, type, meth = @driver.parse_name '#foo'
+
+    assert_equal '',    klass, '#foo class'
+    assert_equal '#',   type,  '#foo type'
+    assert_equal 'foo', meth,  '#foo method'
+
+    klass, type, meth = @driver.parse_name '::foo'
+
+    assert_equal '',    klass, '::foo class'
+    assert_equal '::',  type,  '::foo type'
+    assert_equal 'foo', meth,  '::foo method'
+  end
+
+  def test_parse_name_single_class
+    klass, type, meth = @driver.parse_name 'Foo'
+
+    assert_equal 'Foo', klass, 'Foo class'
+    assert_equal nil,   type,  'Foo type'
+    assert_equal nil,   meth,  'Foo method'
+
+    klass, type, meth = @driver.parse_name 'Foo#'
+
+    assert_equal 'Foo', klass, 'Foo# class'
+    assert_equal '#',   type,  'Foo# type'
+    assert_equal nil,   meth,  'Foo# method'
+
+    klass, type, meth = @driver.parse_name 'Foo::'
+
+    assert_equal 'Foo', klass, 'Foo:: class'
+    assert_equal '::',  type,  'Foo:: type'
+    assert_equal nil,   meth,  'Foo:: method'
+
+    klass, type, meth = @driver.parse_name 'Foo.'
+
+    assert_equal 'Foo', klass, 'Foo. class'
+    assert_equal '.',   type,  'Foo. type'
+    assert_equal nil,   meth,  'Foo. method'
+
+    klass, type, meth = @driver.parse_name 'Foo#Bar'
+
+    assert_equal 'Foo', klass, 'Foo#Bar class'
+    assert_equal '#',   type,  'Foo#Bar type'
+    assert_equal 'Bar', meth,  'Foo#Bar method'
+
+    klass, type, meth = @driver.parse_name 'Foo.Bar'
+
+    assert_equal 'Foo', klass, 'Foo.Bar class'
+    assert_equal '.',   type,  'Foo.Bar type'
+    assert_equal 'Bar', meth,  'Foo.Bar method'
+
+    klass, type, meth = @driver.parse_name 'Foo::bar'
+
+    assert_equal 'Foo', klass, 'Foo::bar class'
+    assert_equal '::',  type,  'Foo::bar type'
+    assert_equal 'bar', meth,  'Foo::bar method'
+  end
+
+  def test_parse_name_namespace
+    klass, type, meth = @driver.parse_name 'Foo::Bar'
+
+    assert_equal 'Foo::Bar', klass, 'Foo::Bar class'
+    assert_equal nil,        type,  'Foo::Bar type'
+    assert_equal nil,        meth,  'Foo::Bar method'
+
+    klass, type, meth = @driver.parse_name 'Foo::Bar#'
+
+    assert_equal 'Foo::Bar', klass, 'Foo::Bar# class'
+    assert_equal '#',        type,  'Foo::Bar# type'
+    assert_equal nil,        meth,  'Foo::Bar# method'
+
+    klass, type, meth = @driver.parse_name 'Foo::Bar#baz'
+
+    assert_equal 'Foo::Bar', klass, 'Foo::Bar#baz class'
+    assert_equal '#',        type,  'Foo::Bar#baz type'
+    assert_equal 'baz',      meth,  'Foo::Bar#baz method'
+  end
+
+  def test_parse_name_special
+    specials = %w[
+      %
+      &
+      *
+      +
+      +@
+      -
+      -@
+      /
+      <
+      <<
+      <=
+      <=>
+      ==
+      ===
+      =>
+      =~
+      >
+      >>
+      []
+      []=
+      ^
+      `
+      |
+      ~
+      ~@
+    ]
+
+    specials.each do |special|
+      parsed = @driver.parse_name special
+
+      assert_equal ['', '.', special], parsed
+    end
+  end
+
+  def _test_setup_pager # this test doesn't do anything anymore :(
+    @driver.use_stdout = false
+
+    pager = with_dummy_pager do @driver.setup_pager end
+
+    skip "couldn't find a standard pager" unless pager
+
+    assert @driver.paging?
+  ensure
+    pager.close if pager
+  end
+
+  def util_ancestors_store
+    store1 = RDoc::RI::Store.new @home_ri
+    store1.cache[:ancestors] = {
+      'Foo'      => %w[Object],
+      'Foo::Bar' => %w[Foo],
+    }
+    store1.cache[:class_methods] = {
+      'Foo'      => %w[c_method new],
+      'Foo::Bar' => %w[new],
+    }
+    store1.cache[:instance_methods] = {
+      'Foo' => %w[i_method],
+    }
+    store1.cache[:modules] = %w[
+      Foo
+      Foo::Bar
+    ]
+
+    store2 = RDoc::RI::Store.new @home_ri
+    store2.cache[:ancestors] = {
+      'Foo'    => %w[Mixin Object],
+      'Mixin'  => %w[],
+      'Object' => %w[X Object],
+      'X'      => %w[Object],
+    }
+    store2.cache[:class_methods] = {
+      'Foo'    => %w[c_method new],
+      'Mixin'  => %w[],
+      'X'      => %w[],
+      'Object' => %w[],
+    }
+    store2.cache[:instance_methods] = {
+      'Foo'   => %w[i_method],
+      'Mixin' => %w[],
+    }
+    store2.cache[:modules] = %w[
+      Foo
+      Mixin
+      Object
+      X
+    ]
+
+    @driver.stores = store1, store2
+  end
+
+  def util_multi_store
+    util_store
+
+    @store1 = @store
+
+    @top_level = RDoc::TopLevel.new 'file.rb'
+
+    @home_ri2 = "#{@home_ri}2"
+    @store2 = RDoc::RI::Store.new @home_ri2
+
+    # as if seen in a namespace like class Ambiguous::Other
+    @mAmbiguous = @top_level.add_module RDoc::NormalModule, 'Ambiguous'
+
+    @cFoo = @top_level.add_class RDoc::NormalClass, 'Foo'
+
+    @cBar = @top_level.add_class RDoc::NormalClass, 'Bar', 'Foo'
+    @cFoo_Baz = @cFoo.add_class RDoc::NormalClass, 'Baz'
+
+    @baz = @cBar.add_method RDoc::AnyMethod.new(nil, 'baz')
+    @baz.record_location @top_level
+
+    @override = @cBar.add_method RDoc::AnyMethod.new(nil, 'override')
+    @override.comment = 'must be displayed'
+    @override.record_location @top_level
+
+    @store2.save_class @mAmbiguous
+    @store2.save_class @cBar
+    @store2.save_class @cFoo_Baz
+
+    @store2.save_method @cBar, @override
+    @store2.save_method @cBar, @baz
+
+    @store2.save_cache
+
+    @driver.stores = [@store1, @store2]
+
+    RDoc::RDoc.reset
+  end
+
+  def util_store
+    @store = RDoc::RI::Store.new @home_ri
+
+    @top_level = RDoc::TopLevel.new 'file.rb'
+
+    @cFoo = @top_level.add_class RDoc::NormalClass, 'Foo'
+    @mInc = @top_level.add_module RDoc::NormalModule, 'Inc'
+    @cAmbiguous = @top_level.add_class RDoc::NormalClass, 'Ambiguous'
+
+    doc = @RM::Document.new @RM::Paragraph.new('Include thingy')
+    @cFooInc = @cFoo.add_include RDoc::Include.new('Inc', doc)
+    @cFooInc.record_location @top_level
+
+    @cFoo_Bar = @cFoo.add_class RDoc::NormalClass, 'Bar'
+
+    @blah = @cFoo_Bar.add_method RDoc::AnyMethod.new(nil, 'blah')
+    @blah.call_seq = "blah(5) => 5\nblah(6) => 6\n"
+    @blah.record_location @top_level
+
+    @bother = @cFoo_Bar.add_method RDoc::AnyMethod.new(nil, 'bother')
+    @bother.block_params = "stuff"
+    @bother.params = "(things)"
+    @bother.record_location @top_level
+
+    @new = @cFoo_Bar.add_method RDoc::AnyMethod.new nil, 'new'
+    @new.record_location @top_level
+    @new.singleton = true
+
+    @attr = @cFoo_Bar.add_attribute RDoc::Attr.new nil, 'attr', 'RW', ''
+    @attr.record_location @top_level
+
+    @cFoo_Baz = @cFoo.add_class RDoc::NormalClass, 'Baz'
+    @cFoo_Baz.record_location @top_level
+
+    @inherit = @cFoo.add_method RDoc::AnyMethod.new(nil, 'inherit')
+    @inherit.record_location @top_level
+
+    # overriden by Bar in multi_store
+    @overriden = @cFoo.add_method RDoc::AnyMethod.new(nil, 'override')
+    @overriden.comment = 'must not be displayed'
+    @overriden.record_location @top_level
+
+    @store.save_class @cFoo
+    @store.save_class @cFoo_Bar
+    @store.save_class @cFoo_Baz
+    @store.save_class @mInc
+    @store.save_class @cAmbiguous
+
+    @store.save_method @cFoo_Bar, @blah
+    @store.save_method @cFoo_Bar, @bother
+    @store.save_method @cFoo_Bar, @new
+    @store.save_method @cFoo_Bar, @attr
+
+    @store.save_method @cFoo, @inherit
+    @store.save_method @cFoo, @overriden
+
+    @store.save_cache
+
+    @driver.stores = [@store]
+
+    RDoc::RDoc.reset
+  end
+
+end
+