rdoc 2.1.0 → 2.2.0

data/lib/rdoc/ri/formatter.rb

@@ -93,7 +93,7 @@ class RDoc::RI::Formatter
   end
 
   def raw_print_line(txt)
-    @output.puts txt
+    @output.print txt
   end
 
   ##

data/lib/rdoc/ri/paths.rb

@@ -26,9 +26,9 @@ module RDoc::RI::Paths
 
   DOC_DIR  = "doc/rdoc"
 
-  version = RbConfig::CONFIG['ruby_version']
+  VERSION = RbConfig::CONFIG['ruby_version']
 
-  base    = File.join(RbConfig::CONFIG['datadir'], "ri", version)
+  base    = File.join(RbConfig::CONFIG['datadir'], "ri", VERSION)
   SYSDIR  = File.join(base, "system")
   SITEDIR = File.join(base, "site")
   homedir = ENV['HOME'] || ENV['USERPROFILE'] || ENV['HOMEPATH']
@@ -39,9 +39,6 @@ module RDoc::RI::Paths
     HOMEDIR = nil
   end
 
-  # This is the search path for 'ri'
-  PATH = [ SYSDIR, SITEDIR, HOMEDIR ].find_all {|p| p && File.directory?(p)}
-
   begin
     require 'rubygems' unless defined?(Gem) and defined?(Gem::Enable) and
                               Gem::Enable
@@ -67,7 +64,6 @@ module RDoc::RI::Paths
     end
 
     GEMDIRS = ri_paths.map { |k,v| v.last }.sort
-    GEMDIRS.each { |dir| PATH << dir }
   rescue LoadError
     GEMDIRS = []
   end
@@ -85,9 +81,6 @@ module RDoc::RI::Paths
   # found.
 
   def self.raw_path(use_system, use_site, use_home, use_gems, *extra_dirs)
-    return PATH unless use_system or use_site or use_home or use_gems or
-                       not extra_dirs.empty?
-
     path = []
     path << extra_dirs unless extra_dirs.empty?
     path << SYSDIR if use_system
@@ -97,6 +90,4 @@ module RDoc::RI::Paths
 
     return path.flatten.compact
   end
-
 end
-

data/lib/rdoc/ri/reader.rb

@@ -45,7 +45,7 @@ class RDoc::RI::Reader
 
   def get_method(method_entry)
     path = method_entry.path_name
-    File.open(path) { |f| RI::Description.deserialize(f) }
+    File.open(path) { |f| RDoc::RI::Description.deserialize(f) }
   end
 
   ##
@@ -54,8 +54,8 @@ class RDoc::RI::Reader
   def get_class(class_entry)
     result = nil
     for path in class_entry.path_names
-      path = RiWriter.class_desc_path(path, class_entry)
-      desc = File.open(path) {|f| RI::Description.deserialize(f) }
+      path = RDoc::RI::Writer.class_desc_path(path, class_entry)
+      desc = File.open(path) {|f| RDoc::RI::Description.deserialize(f) }
       if result
         result.merge_in(desc)
       else

data/lib/rdoc/ri/util.rb

@@ -1,7 +1,5 @@
 require 'rdoc/ri'
 
-class RDoc::RI::Error < RuntimeError; end
-
 ##
 # Break argument into its constituent class or module names, an
 # optional method type, and a method name

data/test/rdoc_markup_to_html_crossref_reference.rb

@@ -0,0 +1,31 @@
+#
+# This file is parsed by test_rdoc_markup_to_html_crossref.rb
+# during its tests.
+#
+class Ref_Class1
+end
+
+class Ref_Class2
+  class Ref_Class3
+    def method
+    end
+
+    class Helper1
+      def method?
+      end
+    end
+  end
+end
+
+class Ref_Class3
+  class Helper1
+  end
+
+  class Helper2
+  end
+end
+
+class Ref_Class4
+  class Ref_Class4
+  end
+end

data/test/test_attribute_manager.rb

@@ -0,0 +1,73 @@
+require 'test/unit'
+require 'rdoc/markup/attribute_manager'
+
+class TestAttributeManager < Test::Unit::TestCase
+
+  def setup
+    @am = RDoc::Markup::AttributeManager.new
+    @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
+    assert word_pairs.is_a?(Hash)
+    assert_equal(3, word_pairs.size)
+  end
+
+  def test_initial_html
+    html_tags = @klass::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
+    assert_equal(4,word_pairs.size)
+    assert(word_pairs.has_key?("x"))
+  end
+  
+  def test_add_invalid_word_pair
+    assert_raise ArgumentError do
+      @am.add_word_pair("<", "<", :TEST)
+    end
+  end
+
+  def test_add_word_pair_map
+    @am.add_word_pair("x", "y", :TEST)
+    word_pair_map = @klass::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
+    assert_equal(6, tags.size)
+    assert(tags.has_key?("test"))
+  end
+
+  def test_add_special
+    @am.add_special("WikiWord", :WIKIWORD)
+    specials = @klass::SPECIAL
+    assert_equal(1,specials.size)
+    assert(specials.has_key?("WikiWord"))
+  end
+
+  def silently(&block)
+    warn_level = $VERBOSE
+    $VERBOSE = nil
+    result = block.call
+    $VERBOSE = warn_level
+    result
+  end
+
+end

data/test/test_rdoc_info_formatting.rb

@@ -5,7 +5,7 @@ require 'test/unit'
 require 'rdoc/generator/texinfo'
 
 # From chapter 18 of the Pickaxe 3rd ed. and the TexInfo manual.
-class TestRdocInfoFormatting < Test::Unit::TestCase
+class TestRDocInfoFormatting < Test::Unit::TestCase
   def setup
     @output_dir = File.join Dir.tmpdir, "test_rdoc_info_formatting_#{$$}"
     @output_file = File.join @output_dir, 'rdoc.texinfo'
@@ -19,7 +19,7 @@ class TestRdocInfoFormatting < Test::Unit::TestCase
   end
 
   def teardown
-    FileUtils.rm_rf @output_dir
+    # FileUtils.rm_rf @output_dir
   end
 
   # Make sure tags like *this* do not make HTML
@@ -73,10 +73,10 @@ class TestRdocInfoFormatting < Test::Unit::TestCase
   # === Everything deeper becomes a regular @heading
   # ====== Regardless of its nesting level
   def test_headings
-    assert_match(/@majorheading\{Huge heading should be a @@majorheading\}/)
-    assert_match(/@chapheading\{There is also @@chapheading\}/)
-    assert_match(/@heading\{Everything deeper becomes a regular @@heading\}/)
-    assert_match(/@heading\{Regardless of its nesting level\}/)
+    assert_match(/@majorheading Huge heading should be a @@majorheading/)
+    assert_match(/@chapheading There is also @@chapheading/)
+    assert_match(/@heading Everything deeper becomes a regular @@heading/)
+    assert_match(/@heading Regardless of its nesting level/)
   end
 
   # * list item

data/test/test_rdoc_info_sections.rb

@@ -6,10 +6,10 @@ require 'tmpdir'
 require 'rdoc/generator/texinfo'
 
 # give us access to check this stuff before it's rendered
-class RDoc::Generator::Texinfo; attr_reader :files, :classes; end
+class RDoc::Generator::TEXINFO; attr_reader :files, :classes; end
 class RDoc::RDoc; attr_reader :options; attr_reader :gen; end
 
-class TestRdocInfoSections < Test::Unit::TestCase
+class TestRDocInfoSections < Test::Unit::TestCase
 
   def setup
     @output_dir = File.join Dir.tmpdir, "test_rdoc_info_sections_#{$$}"

data/test/test_rdoc_markup_attribute_manager.rb

@@ -1,5 +1,6 @@
 require "test/unit"
 require "rdoc/markup/inline"
+require "rdoc/markup/to_html_crossref"
 
 class TestRDocMarkupAttributeManager < Test::Unit::TestCase
 
@@ -201,24 +202,23 @@ class TestRDocMarkupAttributeManager < Test::Unit::TestCase
   end
 
   def test_special
-    # class names, variable names, file names, or instance variables
-    @am.add_special(/(
-                       \b([A-Z]\w+(::\w+)*)
-                       | \#\w+[!?=]?
-                       | \b\w+([_\/\.]+\w+)+[!?=]?
-                      )/x,
-                    :CROSSREF)
+    @am.add_special(RDoc::Markup::ToHtmlCrossref::CROSSREF_REGEXP, :CROSSREF)
 
-    assert_equal(["cat"], @am.flow("cat"))
+    #
+    # The apostrophes in "cats'" and "dogs'" suppress the flagging of these
+    # words as potential cross-references, which is necessary for the unit
+    # tests.  Unfortunately, the markup engine right now does not actually
+    # check whether a cross-reference is valid before flagging it.
+    #
+    assert_equal(["cats'"], @am.flow("cats'"))
 
-    assert_equal(["cat ", crossref("#fred"), " dog"].flatten,
-                  @am.flow("cat #fred dog"))
+    assert_equal(["cats' ", crossref("#fred"), " dogs'"].flatten,
+                  @am.flow("cats' #fred dogs'"))
 
-    assert_equal([crossref("#fred"), " dog"].flatten,
-                  @am.flow("#fred dog"))
+    assert_equal([crossref("#fred"), " dogs'"].flatten,
+                  @am.flow("#fred dogs'"))
 
-    assert_equal(["cat ", crossref("#fred")].flatten, @am.flow("cat #fred"))
+    assert_equal(["cats' ", crossref("#fred")].flatten, @am.flow("cats' #fred"))
   end
 
 end
-

data/test/test_rdoc_markup_to_html.rb

@@ -2,7 +2,7 @@ require 'test/unit'
 require 'rdoc/markup'
 require 'rdoc/markup/to_html'
 
-class TestRdocMarkupToHtml < Test::Unit::TestCase
+class TestRDocMarkupToHtml < Test::Unit::TestCase
 
   def setup
     @am = RDoc::Markup::AttributeManager.new
@@ -10,11 +10,23 @@ class TestRdocMarkupToHtml < Test::Unit::TestCase
   end
 
   def test_tt_formatting
-    assert_equal "<p>\n<tt>--</tt> &#8212; <tt>(c)</tt> &#169;\n</p>\n",
-                 util_format("<tt>--</tt> -- <tt>(c)</tt> (c)")
+    assert_equal "<p>\n<tt>--</tt> &#8212; <tt>cats'</tt> cats&#8217;\n</p>\n",
+                 util_format("<tt>--</tt> -- <tt>cats'</tt> cats'")
     assert_equal "<p>\n<b>&#8212;</b>\n</p>\n", util_format("<b>--</b>")
   end
 
+  def test_convert_string_fancy
+    #
+    # The HTML typesetting is broken in a number of ways, but I have fixed
+    # the most glaring issues for single and double quotes.  Note that
+    # "strange" symbols (periods or dashes) need to be at the end of the
+    # test case strings in order to suppress cross-references.
+    #
+    assert_equal "<p>\n&#8220;cats&#8221;.\n</p>\n", util_format("\"cats\".")
+    assert_equal "<p>\n&#8216;cats&#8217;.\n</p>\n", util_format("\'cats\'.")
+    assert_equal "<p>\ncat&#8217;s-\n</p>\n", util_format("cat\'s-")
+  end
+
   def util_fragment(text)
     RDoc::Markup::Fragment.new 0, nil, nil, text
   end

data/test/test_rdoc_markup_to_html_crossref.rb

@@ -2,17 +2,286 @@ require 'test/unit'
 require 'rdoc/generator'
 require 'rdoc/markup/to_html_crossref'
 
-class TestRdocMarkupToHtmlCrossref < Test::Unit::TestCase
+require 'pathname'
 
-  def setup
-    @xref = RDoc::Markup::ToHtmlCrossref.new 'from_path', nil, nil
+class TestRDocMarkupToHtmlCrossref < Test::Unit::TestCase
+
+  #
+  # This method parses a source file and returns a Hash mapping
+  # class names (Strings) to RDoc::Generator::Class instances
+  # (classes), which can be used to create RDoc::Markup::ToHtmlCrossref
+  # instances.  The unit tests only test against classes starting with
+  # Ref_, so this method only includes such classes in the Hash.
+  #
+  def create_class_hash
+    # The relative gem would help here...
+    # @source_file_name must be cleaned because rdoc does not deal
+    # well with paths containing "." or "..".
+    curr_file = Pathname.new(__FILE__)
+    @source_file_name = curr_file.dirname + "rdoc_markup_to_html_crossref_reference.rb"
+    @source_file_name = @source_file_name.cleanpath.to_s
+
+    RDoc::TopLevel.reset
+
+    # Reset RDoc::Generator::Method so that the method sequence number starts
+    # at 1, making the method sequence numbers for the methods in the Ref_
+    # predicable.
+    RDoc::Generator::Method.reset
+    top_level = RDoc::TopLevel.new @source_file_name
+    
+    options = RDoc::Options.new
+    options.quiet = true
+
+    # If this is false, then RDoc::Generator::Method will attempt to create
+    # an HTML file containing the method source code when being instantiated,
+    # which does not work in the context of this unit test.
+    #
+    # RDoc::Generator::Method needs to be refactored so that this does *not*
+    # happen as part of instantiation.
+    options.inline_source = true
+
+    stats = RDoc::Stats.new 0
+
+    parser = RDoc::Parser::Ruby.new(top_level,
+                                    @source_file_name,
+                                    IO.read(@source_file_name),
+                                    options,
+                                    stats)
+    top_levels = []
+    top_levels.push(parser.scan())
+
+    files, classes = RDoc::Generator::Context.build_indices(top_levels, options)
+
+    class_hash = {}
+    classes.each do |klass|
+      if(klass.name.include?("Ref_"))
+        class_hash[klass.name] = klass
+      end
+    end
+
+    return class_hash
   end
 
-  def test_handle_special_CROSSREF_no_underscore
-    out = @xref.convert 'foo'
+  #
+  # This method uses xref to cross-reference String reference and
+  # asserts that xref.convert(reference) is equal
+  # to String expected_result.
+  #
+  def verify_convert(xref, reference, expected_result)
+    # Everything converted in the tests will be within paragraph markup, so
+    # add paragraph markup to the expected result.
+    actual_expected_result = "<p>\n#{expected_result}\n</p>\n"
+
+    result = xref.convert(reference)
+
+    # RDoc::Markup::ToHtml word-wraps lines.  It is tricky to predict where
+    # a line will be wrapped except that it will happen on a space, so replace
+    # all newlines with spaces in order to not have to worry about this.
+    actual_expected_result.gsub!(/\n/, " ")
+    result.gsub!(/\n/, " ")
 
-    assert_equal "<p>\nfoo\n</p>\n", out
+    assert_equal actual_expected_result, result
   end
 
-end
+  #
+  # This method verifies that xref generates no cross-reference link for
+  # String reference.
+  #
+  def verify_no_crossref(xref, reference)
+    if(reference[0, 1] == "\\") # Remove the markup suppression character
+      expected_result = reference[1, reference.length() - 1]
+    else
+      expected_result = reference
+    end
+
+    verify_convert(xref, reference, expected_result)
+  end
+
+  #
+  # This method verifies that xref generates a cross-reference link to
+  # class_name (String) for String reference.
+  #
+  def verify_class_crossref(xref, reference, class_name)
+    class_file_name = class_name.gsub(/::/, "/")
+    
+    result = "<a href=\"../classes/#{class_file_name}.html\">#{reference}</a>"
+
+    verify_convert xref, reference, result
+  end
 
+  #
+  # This method verifies that xref generates a cross-reference link to method
+  # method_seq (String, e.g, "M000001") in class_name (String) for
+  # String reference.
+  #
+  def verify_method_crossref(xref, reference, class_name, method_seq)
+    class_file_name = class_name.gsub(/::/, "/")
+    
+    result = "<a href=\"../classes/#{class_file_name}.html##{method_seq}\">#{reference}</a>"
+
+    verify_convert xref, reference, result
+  end
+
+  #
+  # This method verifies that xref generates a cross-reference link to
+  # file_name (String) for String reference.
+  #
+  def verify_file_crossref(xref, reference, file_name)
+    result = "<a href=\"../files/#{file_name.gsub(/\./, '_')}.html\">#{reference}</a>"
+
+    verify_convert xref, reference, result
+  end
+
+  #
+  # This method verifies that several invariant cross-references are
+  # (or are not) generated.
+  #
+  def verify_invariant_crossrefs(xref)
+    # bogus does not exist and so no cross-reference should be generated.
+    verify_no_crossref xref, "bogus"
+    verify_no_crossref xref, "\\bogus"
+    
+    # Ref_Class1 is in the top-level namespace, and so a cross-reference always
+    # should be generated, unless markup is suppressed.
+    verify_class_crossref xref, "Ref_Class1", "Ref_Class1"
+    verify_no_crossref xref, "\\Ref_Class1"
+
+    # Ref_Class2 is in the top-level namespace, and so a cross-reference always
+    # should be generated for it and for its nested classes.
+    verify_class_crossref xref, "Ref_Class2", "Ref_Class2"
+    verify_class_crossref xref, "Ref_Class2::Ref_Class3", "Ref_Class2::Ref_Class3"
+    verify_method_crossref xref, "Ref_Class2::Ref_Class3#method", "Ref_Class2::Ref_Class3", "M000001"
+    verify_method_crossref xref, "Ref_Class2::Ref_Class3#method()", "Ref_Class2::Ref_Class3", "M000001"
+    verify_method_crossref xref, "Ref_Class2::Ref_Class3.method()", "Ref_Class2::Ref_Class3", "M000001"
+    verify_method_crossref xref, "Ref_Class2::Ref_Class3.method(*)", "Ref_Class2::Ref_Class3", "M000001"
+    verify_class_crossref xref, "Ref_Class2::Ref_Class3::Helper1", "Ref_Class2::Ref_Class3::Helper1"
+    verify_method_crossref xref, "Ref_Class2::Ref_Class3::Helper1#method?", "Ref_Class2::Ref_Class3::Helper1", "M000002"
+
+    # The hyphen character is not a valid class/method separator character, so
+    # rdoc just generates a class cross-reference (perhaps it should not
+    # generate anything?).
+    result = "<a href=\"../classes/Ref_Class2/Ref_Class3.html\">Ref_Class2::Ref_Class3</a>;method(*)"
+    verify_convert xref, "Ref_Class2::Ref_Class3;method(*)", result
+
+    # There is one Ref_Class3 nested in Ref_Class2 and one defined in the
+    # top-level namespace; regardless, ::Ref_Class3 (Ref_Class3 relative
+    # to the top-level namespace) always should generate a link to the
+    # top-level Ref_Class3 (unless of course cross-references are suppressed).
+    verify_class_crossref xref, "::Ref_Class3", "Ref_Class3"
+    verify_no_crossref xref, "\\::Ref_Class3"
+    verify_class_crossref xref, "::Ref_Class3::Helper1", "Ref_Class3::Helper1"
+    verify_class_crossref xref, "::Ref_Class3::Helper2", "Ref_Class3::Helper2"
+
+    #
+    # Ref_Class3::Helper1 does not have method method.
+    #
+    verify_no_crossref xref, "::Ref_Class3::Helper1#method"
+    verify_no_crossref xref, "\\::Ref_Class3::Helper1#method"
+
+    # References to Ref_Class2 relative to the top-level namespace always should
+    # generate links to Ref_Class2.
+    verify_method_crossref xref, "::Ref_Class2::Ref_Class3#method", "Ref_Class2::Ref_Class3", "M000001"
+    verify_method_crossref xref, "::Ref_Class2::Ref_Class3#method()", "Ref_Class2::Ref_Class3", "M000001"
+    verify_method_crossref xref, "::Ref_Class2::Ref_Class3#method(*)", "Ref_Class2::Ref_Class3", "M000001"
+    verify_class_crossref xref, "::Ref_Class2::Ref_Class3::Helper1", "Ref_Class2::Ref_Class3::Helper1"
+    verify_no_crossref xref, "\\::Ref_Class2::Ref_Class3#method(*)"
+
+    # Suppressing cross-references always should suppress the generation of
+    # links.
+    verify_no_crossref xref, "\\#method"
+    verify_no_crossref xref, "\\#method()"
+    verify_no_crossref xref, "\\#method(*)"
+
+    # Links never should be generated for words solely consisting of lowercase
+    # letters, because too many links would get generated by mistake (i.e., the
+    # word "new" always would be a link).
+    verify_no_crossref xref, "method"
+
+    # A link always should be generated for a file name.
+    verify_file_crossref xref, @source_file_name, @source_file_name
+
+    # References should be generated correctly for a class scoped within
+    # a class of the same name.
+    verify_class_crossref xref, "Ref_Class4::Ref_Class4", "Ref_Class4::Ref_Class4"
+  end
+
+  def test_handle_special_CROSSREF_no_underscore
+    class_hash = create_class_hash
+
+    # Note that we instruct the ToHtmlCrossref instance to show hashes so that
+    # an exception won't have to be made for words starting with a '#'.
+    # I'm also not convinced that the current behavior of the rdoc code
+    # is correct since, without this, it strips the leading # from all
+    # words, whether or not they end up as cross-references.
+    #
+    # After the behavior has been sorted out, this can be changed.
+    #
+    # Create a variety of RDoc::Markup::ToHtmlCrossref instances, for
+    # different classes, and test the cross-references generated by
+    # each.
+    klass = class_hash["Ref_Class1"]
+    xref = RDoc::Markup::ToHtmlCrossref.new 'from_path', klass, true
+    verify_invariant_crossrefs xref
+    verify_class_crossref xref, "Ref_Class3", "Ref_Class3"
+    verify_no_crossref xref, "Ref_Class3#method"
+    verify_no_crossref xref, "#method"
+    verify_class_crossref xref, "Ref_Class3::Helper1", "Ref_Class3::Helper1"
+    verify_class_crossref xref, "Ref_Class3::Helper2", "Ref_Class3::Helper2"
+    verify_no_crossref xref, "Helper1"
+    verify_class_crossref xref, "Ref_Class4", "Ref_Class4"
+
+    klass = class_hash["Ref_Class2"]
+    xref = RDoc::Markup::ToHtmlCrossref.new 'from_path', klass, true
+    verify_invariant_crossrefs xref
+    verify_class_crossref xref, "Ref_Class3", "Ref_Class2::Ref_Class3"
+    verify_method_crossref xref, "Ref_Class3#method", "Ref_Class2::Ref_Class3", "M000001"
+    verify_no_crossref xref, "#method"
+    verify_class_crossref xref, "Ref_Class3::Helper1", "Ref_Class2::Ref_Class3::Helper1"
+    verify_class_crossref xref, "Ref_Class4", "Ref_Class4"
+
+    # This one possibly is an rdoc bug...
+    # Ref_Class2 has a nested Ref_Class3, but
+    # Ref_Class2::Ref_Class3::Helper2 does not exist.
+    # On the other hand, there is a Ref_Class3::Helper2
+    # in the top-level namespace...  Should rdoc stop
+    # looking if it finds one class match?
+    verify_no_crossref xref, "Ref_Class3::Helper2"
+    verify_no_crossref xref, "Helper1"
+
+    klass = class_hash["Ref_Class2::Ref_Class3"]
+    xref = RDoc::Markup::ToHtmlCrossref.new 'from_path', klass, true
+    verify_invariant_crossrefs xref
+    verify_class_crossref xref, "Ref_Class3", "Ref_Class2::Ref_Class3"
+    verify_method_crossref xref, "Ref_Class3#method", "Ref_Class2::Ref_Class3", "M000001"
+    verify_method_crossref xref, "#method", "Ref_Class2::Ref_Class3", "M000001"
+    verify_class_crossref xref, "Ref_Class3::Helper1", "Ref_Class2::Ref_Class3::Helper1"
+    verify_no_crossref xref, "Ref_Class3::Helper2"
+    verify_class_crossref xref, "Helper1", "Ref_Class2::Ref_Class3::Helper1"
+    verify_class_crossref xref, "Ref_Class4", "Ref_Class4"
+
+    klass = class_hash["Ref_Class3"]
+    xref = RDoc::Markup::ToHtmlCrossref.new 'from_path', klass, true
+    verify_invariant_crossrefs xref
+    verify_class_crossref xref, "Ref_Class3", "Ref_Class3"
+    verify_no_crossref xref, "Ref_Class3#method"
+    verify_no_crossref xref, "#method"
+    verify_class_crossref xref, "Ref_Class3::Helper1", "Ref_Class3::Helper1"
+    verify_class_crossref xref, "Ref_Class3::Helper2", "Ref_Class3::Helper2"
+    verify_class_crossref xref, "Helper1", "Ref_Class3::Helper1"
+    verify_class_crossref xref, "Ref_Class4", "Ref_Class4"
+
+    klass = class_hash["Ref_Class4"]
+    xref = RDoc::Markup::ToHtmlCrossref.new 'from_path', klass, true
+    verify_invariant_crossrefs xref
+    # A Ref_Class4 reference inside a Ref_Class4 class containing a
+    # Ref_Class4 class should resolve to the contained class.
+    verify_class_crossref xref, "Ref_Class4", "Ref_Class4::Ref_Class4"
+
+    klass = class_hash["Ref_Class4::Ref_Class4"]
+    xref = RDoc::Markup::ToHtmlCrossref.new 'from_path', klass, true
+    verify_invariant_crossrefs xref
+    # A Ref_Class4 reference inside a Ref_Class4 class contained within
+    # a Ref_Class4 class should resolve to the inner Ref_Class4 class.
+    verify_class_crossref xref, "Ref_Class4", "Ref_Class4::Ref_Class4"
+  end
+end