dakrone-fastri 0.3.1

data/test/test_full_text_index.rb

@@ -0,0 +1,182 @@
+require 'test/unit'
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+$:.unshift "lib"
+require 'fastri/full_text_index'
+
+class TestFullTextIndex < Test::Unit::TestCase
+  require 'stringio'
+  include FastRI
+
+  magic = FullTextIndexer::MAGIC
+  data = <<EOF
+#{magic}this is a test 
+\r\000\000\000foo.txt\000\004\b{\000
+zzzz
+\r\000\000\000bar.txt\000\004\b{\000
+EOF
+  DATA = (data.split(/\n/) << "").join("\0")
+  SUFFIXES = %w[a\ test is\ a test this zzzz].map{|w| [DATA.index(w)].pack("V")}.join("")
+
+  data = <<EOF
+#{magic}this is a test 
+\r\000\000\000foo.txt\000\004\b{\000
+zzzz this
+\r\000\000\000bar.txt\000\004\b{\000
+EOF
+  DATA2 = (data.split(/\n/) << "").join("\0")
+  SUFFIXES2 = ["a test", "is a", "test", "this\0", "this", "zzzz"].map{|x| [DATA2.index(x)].pack("V")}.join("")
+
+  data = <<EOF
+#{magic}this is a test 
+SIZ1foo.txt\000#{Marshal.dump({:foo => :bar, :bar => 1})}
+zzzz this
+SIZ2bar.txt\000#{Marshal.dump({:foo => :baz, :bar => 42})}
+EOF
+  lines = data.split(/\n/)
+  len1 = lines[1].size - 4 + 1
+  lines[1].sub!(/SIZ1/, [len1].pack("V"))
+  len2 = lines[3].size - 4 + 1
+  lines[3].sub!(/SIZ2/, [len2].pack("V"))
+  DATA3 = (lines << "").join("\0")
+  SUFFIXES3 = ["a test", "is a", "test", "this\0", "this", "zzzz"].map{|x| [DATA3.index(x)].pack("V")}.join("")
+
+  def setup
+    @index = FullTextIndex.new_from_ios(StringIO.new(DATA), StringIO.new(SUFFIXES))
+    @index2 = FullTextIndex.new_from_ios(StringIO.new(DATA2), StringIO.new(SUFFIXES2))
+    @index3 = FullTextIndex.new_from_ios(StringIO.new(DATA3), StringIO.new(SUFFIXES3))
+  end
+
+  def test_new_from_ios
+    a = nil
+    assert_nothing_raised { a = FullTextIndex.new_from_ios(StringIO.new(DATA), StringIO.new(SUFFIXES)) }
+    assert_equal(FullTextIndex::DEFAULT_OPTIONS[:max_query_size], a.max_query_size)
+  end
+  
+  def test_lookup_basic
+    %w[this is a test].each do |term|
+      result = @index.lookup(term)
+      assert_kind_of(FullTextIndex::Result, result)
+      assert_equal(term, result.query)
+      assert_equal("foo.txt", result.path)
+    end
+    assert_equal(0, @index.lookup("a").index)
+    assert_equal(2, @index.lookup("t").index)
+    assert_equal(3, @index.lookup("th").index)
+
+    assert_equal(4, @index.lookup("z").index)
+    assert_equal("bar.txt", @index.lookup("z").path)
+  end
+
+  def test_lookup_metadata
+    assert_equal({}, @index.lookup("test").metadata)
+    assert_equal({}, @index.lookup("zzzz").metadata)
+    assert_equal({:foo => :bar, :bar => 1}, @index3.lookup("test").metadata)
+    assert_equal({:foo => :baz, :bar => 42}, @index3.lookup("zzz").metadata)
+  end
+
+  def test_Result_text
+    assert_equal("t", @index.lookup("this").text(1))
+    assert_equal("this", @index.lookup("this").text(4))
+    assert_equal("this is a ", @index.lookup("this").text(10))
+    assert_equal("this is a test ", @index.lookup("th").text(100))
+
+    assert_equal("test ", @index.lookup("t").text(10))
+    assert_equal("test ", @index.lookup("t").text(20))
+
+    assert_equal("z", @index.lookup("z").text(1))
+    assert_equal("zzzz", @index.lookup("z").text(10))
+  end
+
+  def test_Result_context
+    assert_equal(" a ", @index.lookup("a").context(1))
+    assert_equal("s a t", @index.lookup("a").context(2))
+    assert_equal("is a te", @index.lookup("a").context(3))
+    assert_equal("s is a test", @index.lookup("a").context(5))
+    assert_equal("this is a test ", @index.lookup("a").context(10))
+  end
+
+  def test_Result_context_non_initial_entry
+    assert_equal("zz", @index.lookup("z").context(1))
+    assert_equal("zzz", @index.lookup("z").context(2))
+    assert_equal("zzzz", @index.lookup("z").context(3))
+    assert_equal("zzzz", @index.lookup("z").context(4))
+    assert_equal("zzzz", @index.lookup("z").context(10))
+  end
+
+  def test_lookup_nonexistent
+    assert_nil(@index.lookup("bogus"))
+  end
+
+  def test_next_match_basic
+    first = @index2.lookup("t")
+    assert_equal("foo.txt", first.path)
+    assert_equal(2, first.index)
+    assert_equal("test ", first.text(10))
+
+    second = @index2.next_match(first)
+    assert_equal("bar.txt", second.path)
+    assert_equal(3, second.index)
+    assert_equal("this", second.text(10))
+
+    third = @index2.next_match(second)
+    assert_kind_of(FullTextIndex::Result, third)
+    assert_equal(4, third.index)
+    assert_equal("this is a ", third.text(10))
+
+    assert_nil(@index2.next_match(third))
+  end
+
+  def test_next_match_restricted
+    first = @index2.lookup("t")
+    assert_equal("foo.txt", first.path)
+    assert_equal(2, first.index)
+    assert_equal("test ", first.text(10))
+
+    second = @index2.next_match(first, "this is")
+    assert_equal("foo.txt", second.path)
+    assert_equal(4, second.index)
+    assert_equal("this is a ", second.text(10))
+
+    assert_nil(@index2.next_match(first, "foo"))
+  end
+
+  def test_next_match_regexp
+    first = @index2.lookup("t")
+    assert_equal("foo.txt", first.path)
+    assert_equal(2, first.index)
+    assert_equal("test ", first.text(10))
+
+    second = @index2.next_match(first, /.*test/)
+    assert_equal("foo.txt", second.path)
+    assert_equal(4, second.index)
+    assert_equal("this is a test ", second.text(20))
+  end
+
+
+  def test_next_matches
+    first = @index2.lookup("t")
+    all = [first] + @index2.next_matches(first)
+    assert_equal([2, 3, 4], all.map{|x| x.index})
+    assert_equal(["foo.txt", "bar.txt", "foo.txt"], all.map{|x| x.path})
+    one, two, three = *all
+    assert_equal(["test ", "this", "this is a test "], all.map{|x| x.text(20)})
+  end
+
+  def test_next_matches_restricted
+    first = @index2.lookup("t")
+    assert_equal([], @index2.next_matches(first, "this is not"))
+    all = @index2.next_matches(first, "this is")
+    assert_equal(["foo.txt"], all.map{|x| x.path})
+    assert_equal([4], all.map{|x| x.index})
+    assert_equal(["this is a test "], all.map{|x| x.text(20)})
+  end
+
+  def test_next_matches_regexp
+    first = @index2.lookup("t")
+    all = @index2.next_matches(first, /.*test/)
+    assert_equal(["foo.txt"], all.map{|x| x.path})
+    assert_equal([4], all.map{|x| x.index})
+    assert_equal(["this is a test "], all.map{|x| x.text(20)})
+  end
+
+end

data/test/test_full_text_indexer.rb

@@ -0,0 +1,84 @@
+require 'test/unit'
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+$:.unshift "lib"
+require 'fastri/full_text_indexer'
+
+class TestFullTextIndexer < Test::Unit::TestCase
+  require 'stringio'
+  include FastRI
+  def setup
+    @indexer = FullTextIndexer.new(20)
+  end
+
+  DATA1 =  "this is a test " * 1000
+  DATA2 =  "this is another test " * 1000
+  def test_add_document
+    @indexer.add_document("foo.txt", DATA1)
+    assert_equal(["foo.txt"], @indexer.documents)
+    assert_equal(DATA1, @indexer.data("foo.txt"))
+    @indexer.add_document("foo.txt", DATA2)
+    assert_equal(["foo.txt"], @indexer.documents)
+    assert_equal(DATA2, @indexer.data("foo.txt"))
+    @indexer.add_document("bar.txt", DATA2)
+    assert_equal(["foo.txt", "bar.txt"], @indexer.documents)
+    assert_equal(DATA2, @indexer.data("bar.txt"))
+  end
+
+  def test_preprocess
+    data = "this is a \0foo bar\0 bla"
+    assert_equal("this is a foo bar bla", @indexer.preprocess(data))
+  end
+
+  def test_find_suffixes_simple
+    data = <<EOF
+this is a simple test with these words: Aaaa01 0.1 _asdA1
+EOF
+    assert_equal([0, 5, 8, 10, 17, 22, 27, 33, 40, 47, 49, 51], 
+                 @indexer.find_suffixes_simple(data, /[A-Za-z0-9_]+/, /[^A-Za-z0-9_]+/,0))
+    assert_equal([0, 5, 8, 10, 17, 22, 27, 33, 40, 52], 
+                 @indexer.find_suffixes_simple(data, /[A-Za-z]+/, /[^A-Za-z]+/, 0))
+    assert_equal([0, 5, 8, 10, 17, 22, 27, 33, 40, 52].map{|x| x+10}, 
+                 @indexer.find_suffixes_simple(data, /[A-Za-z]+/, /[^A-Za-z]+/, 10))
+    assert_equal([0, 1, 2, 3, 5, 6, 8, 10, 11, 12, 13, 14, 15, 17, 18, 19, 20, 
+                 22, 23, 24, 25, 27, 28, 29, 30, 31, 33, 34, 35, 36, 37,
+    
+                 40, 41, 42, 43, 52, 53, 54, 55], 
+                 @indexer.find_suffixes_simple(data, /[A-Za-z]/, /[^A-Za-z]+/, 0))
+    assert_equal([0, 5], @indexer.find_suffixes_simple("abcd\ndefg", /\S+/, /\s+/, 0))
+    assert_equal([1, 6], @indexer.find_suffixes_simple("abcd\ndefg", /\S+/, /\s+/, 1))
+  end
+
+  def test_build_index_trivial
+    @indexer.add_document("foo.txt", DATA1)
+    fulltext    = StringIO.new("")
+    suffixarray = StringIO.new("")
+    @indexer.build_index(fulltext, suffixarray)
+    assert_equal(["\000\027\000\000\000foo.txt\000\004\b{\006:\tsizei\002\230:\000"], 
+                 fulltext.string[-200..-1].scan(/\0.*$/))
+    assert_equal(4000 * 4, suffixarray.string.size)
+  end
+
+  def build_index_test_helper(data, suffixes)
+    @indexer.add_document("foo.txt", data)
+    offset = FullTextIndexer::MAGIC.size
+    suffixes = suffixes.map{|x| x + offset}
+    sorted   = suffixes.sort_by{|i| data[i - offset]}
+    f_io  = StringIO.new("")
+    sa_io = StringIO.new("")
+    @indexer.build_index(f_io, sa_io)
+    assert_equal(sorted, sa_io.string.scan(/..../m).map{|x| x.unpack("V")[0]})
+  end
+
+  def test_build_index_harder
+    data = <<EOF
+a bcd efghi jklmn opqrst
+EOF
+    suffixes = [0, 2, 6, 12, 18]
+    build_index_test_helper(data, suffixes)
+    data = <<EOF
+e xcd afghi zklmn bpqrst
+EOF
+    suffixes = [0, 2, 6, 12, 18]
+    build_index_test_helper(data, suffixes)
+  end
+end

data/test/test_functional_ri_service.rb

@@ -0,0 +1,60 @@
+require 'test/unit'
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'fastri/ri_service'
+require 'fastri/ri_index'
+
+class TestFunctionalRiService < Test::Unit::TestCase
+  # only created once, since it takes a long time
+  @@ri = FastRI::RiService.new(FastRI::RiIndex.new_from_paths(::RDoc::RI::Paths.path(true, true, true, true)))
+  def setup
+    @ri = @@ri
+  end
+
+  def assert_include(arr, actual)
+    arr.each{|w| assert(actual.include?(w), "#{w} should be included in #{actual}") }
+  end
+
+  def test_completion_list
+    completion_each = %w[each_pair each_byte each_key each_value]
+    assert_include(completion_each, @ri.completion_list("each_"))
+    assert_kind_of(Array, @ri.completion_list("each_"))
+
+    assert_include(%w[Array Fixnum Hash String], @ri.completion_list(""))
+    assert_kind_of(Array, @ri.completion_list(""))
+
+    assert_include(%w[Array ArgumentError], @ri.completion_list("Ar"))
+  end
+
+  def test_info
+    assert_include(%w[collect collect! compact compact! concat],
+                    @ri.info("Array"))
+    assert_include(%w[each each_key each_pair each_value empty],
+                    @ri.info("Hash"))
+    assert_kind_of(String, @ri.info("Hash"))
+  end
+
+  def test_args
+    assert_match(/map\s+\{\|\s*\w+\s*\|\s+block\s+\}/, 
+                 @ri.args("map"))
+    assert_kind_of(String,@ri.args("map"))
+  end
+
+  def test_class_list
+    assert_include(%w[StringIO Range Array Hash String Struct],
+                   @ri.class_list("each"))
+    assert_kind_of(Array, @ri.class_list("each"))
+    assert_include(%w[Hash Struct],
+                   @ri.class_list("each_pair"))
+    assert_equal(nil, @ri.class_list("__super_bogus_method___"))
+  end
+
+  def test_class_list_with_flag
+    assert_include(%w[StringIO# Range# Array# Hash# String# Struct#],
+                   @ri.class_list_with_flag("each"))
+    assert_include(%w[Hash# Struct#],
+                   @ri.class_list_with_flag("each_pair"))
+    assert_equal(nil, @ri.class_list_with_flag("__super_bogus_method___"))
+  end
+end
+
+

data/test/test_integration_full_text_index.rb

@@ -0,0 +1,43 @@
+# Copyright (C) 2006  Mauricio Fernandez <mfp@acm.org>
+#
+
+require 'test/unit'
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+$:.unshift "lib"
+require 'fastri/full_text_indexer'
+require 'fastri/full_text_index'
+
+class TestIntegrationFullTextIndex < Test::Unit::TestCase
+  include FastRI
+  def setup
+    @indexer = FullTextIndexer.new(20)
+  end
+
+  require 'stringio'
+  def get_index
+    fulltextIO = StringIO.new("")
+    suffixIO   = StringIO.new("")
+    @indexer.build_index(fulltextIO, suffixIO)
+    FullTextIndex.new_from_ios(fulltextIO, suffixIO)
+  end
+
+  def test_basic_matching
+    @indexer.add_document("first.txt", "this is the first document: foo")
+    @indexer.add_document("second.txt", "this is the second document: bar")
+    index = get_index
+    assert_equal("first.txt", index.lookup("foo").path)
+    assert_equal("second.txt", index.lookup("bar").path)
+  end
+
+  def test_metadata
+    @indexer.add_document("first.txt", "this is the first document: foo",
+                          :type => "text/plain", :foo => 'baz')
+    @indexer.add_document("second.doc", "this is the second document: bar",
+                          :type => "application/msword", :bar => "foo")
+    index = get_index
+    assert_equal("first.txt", index.lookup("foo").path)
+    assert_equal("second.doc", index.lookup("bar").path)
+    assert_equal({:foo=>"baz", :type=>"text/plain", :size => 31}, index.lookup("foo").metadata)
+    assert_equal({:bar=>"foo", :type=>"application/msword", :size => 32}, index.lookup("bar").metadata)
+  end
+end

data/test/test_name_descriptor.rb

@@ -0,0 +1,35 @@
+# Copyright (C) 2006  Mauricio Fernandez <mfp@acm.org>
+#
+
+require 'test/unit'
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+$:.unshift "lib"
+require 'fastri/name_descriptor'
+
+class TestNameDescriptor < Test::Unit::TestCase
+  include FastRI
+  def helper(text)
+    desc = NameDescriptor.new(text)
+    [desc.class_names, desc.method_name, desc.is_class_method]
+  end
+
+  def test_unqualified_methods
+    assert_equal([[], "foo", nil], helper("foo"))
+    assert_equal([[], "foo", false], helper("#foo"))
+    assert_equal([[], "foo", nil], helper(".foo"))
+    assert_equal([[], "foo", true], helper("::foo"))
+  end
+
+  def test_qualified_methods
+    assert_equal([["Foo"], "bar", nil], helper("foo.bar"))
+    assert_equal([["Foo"], "bar", true], helper("foo::bar"))
+    assert_equal([["Foo"], "bar", false], helper("foo#bar"))
+    assert_equal([["Foo", "Bar"], "baz", true], helper("foo::bar::baz"))
+  end
+
+  def test_namespaces
+    assert_equal([["Foo"], nil, nil], helper("Foo"))
+    assert_equal([["Foo", "Bar"], nil, nil], helper("foo::Bar"))
+    assert_equal([["Foo", "Bar", "Baz"], nil, nil], helper("Foo::Bar::Baz"))
+  end
+end

data/test/test_ri_index.rb

@@ -0,0 +1,389 @@
+require 'test/unit'
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+$:.unshift "lib"
+require 'fastri/ri_index'
+
+class TestRiIndex < Test::Unit::TestCase
+  INDEX_DATA =<<EOF
+#{FastRI::RiIndex::MAGIC}
+Sources:
+system                          /usr/share/ri/system/
+somegem-0.1.0                   /long/path/somegem-0.1.0
+stuff-1.1.0                     /long/path/stuff-1.1.0
+================================================================================
+Namespaces:
+ABC 0 1
+ABC::DEF 0 1
+ABC::DEF::Foo 1
+ABC::Zzz 0
+CDE 1 2
+FGH 2
+FGH::Adfdsf 2
+================================================================================
+Methods:
+ABC::DEF.bar 0
+ABC::DEF::Foo#baz 1
+ABC::DEF::Foo#foo 1
+ABC::Zzz.foo 0 1
+ABC::Zzz#foo 0
+CDE.foo 1 2
+FGH::Adfdsf#foo 2
+================================================================================
+EOF
+  INDEX_DATA2 =<<EOF
+#{FastRI::RiIndex::MAGIC}
+Sources:
+system                          /usr/share/ri/system/
+somegem-0.1.0                   /long/path/somegem-0.1.0
+stuff-1.1.0                     /long/path/stuff-1.1.0
+================================================================================
+Namespaces:
+ABC 0 1
+ABCDEF 1 2
+================================================================================
+Methods:
+ABC.bar 0
+ABC#baz 1
+ABCDEF#foo 1
+ABCDEF.foo 1 2
+================================================================================
+EOF
+
+  require 'stringio'
+  def setup
+    @index = FastRI::RiIndex.new_from_IO(StringIO.new(INDEX_DATA))
+    @index2 = FastRI::RiIndex.new_from_IO(StringIO.new(INDEX_DATA2))
+  end
+
+  def test_dump
+    s = StringIO.new("")
+    @index.dump(s)
+    assert_equal(INDEX_DATA, s.string)
+  end
+
+  def test_toplevel_namespace
+    ret = @index.top_level_namespace
+    assert_kind_of(Array, ret)
+    assert_kind_of(FastRI::RiIndex::TopLevelEntry, ret[0])
+  end
+
+  def test_full_class_names
+    assert_equal(["ABC", "ABC::DEF", "ABC::DEF::Foo", "ABC::Zzz", "CDE", "FGH", "FGH::Adfdsf"], @index.full_class_names)
+    assert_equal(["ABC", "ABC::DEF", "ABC::Zzz"], @index.full_class_names(0))
+    assert_equal(["ABC", "ABC::DEF", "ABC::DEF::Foo", "CDE"], @index.full_class_names(1))
+    assert_equal(["CDE", "FGH", "FGH::Adfdsf"], @index.full_class_names(2))
+    assert_equal(["CDE", "FGH", "FGH::Adfdsf"], @index.full_class_names("stuff-1.1.0"))
+    assert_equal([], @index.full_class_names("nonexistent-1.1.0"))
+  end
+
+  def test_full_method_names
+    assert_equal(["ABC::DEF.bar", "ABC::DEF::Foo#baz", "ABC::DEF::Foo#foo", 
+                 "ABC::Zzz.foo", "ABC::Zzz#foo", "CDE.foo", "FGH::Adfdsf#foo"], 
+                 @index.full_method_names)
+    assert_equal(["ABC::DEF.bar", "ABC::Zzz.foo", "ABC::Zzz#foo"], 
+                 @index.full_method_names(0))
+    assert_equal(["ABC::DEF::Foo#baz", "ABC::DEF::Foo#foo", "ABC::Zzz.foo", "CDE.foo"], 
+                 @index.full_method_names(1))
+    assert_equal(["CDE.foo", "FGH::Adfdsf#foo"], @index.full_method_names(2))
+    assert_equal(["CDE.foo", "FGH::Adfdsf#foo"], @index.full_method_names("stuff-1.1.0"))
+    assert_equal([], @index.full_method_names("nonexistent-1.1.0"))
+  end
+
+  def test_all_names
+    assert_equal(["ABC", "ABC::DEF", "ABC::DEF::Foo", "ABC::Zzz", "CDE", "FGH", 
+                 "FGH::Adfdsf", "ABC::DEF.bar", "ABC::DEF::Foo#baz", 
+                 "ABC::DEF::Foo#foo", "ABC::Zzz.foo", "ABC::Zzz#foo", 
+                 "CDE.foo", "FGH::Adfdsf#foo"], @index.all_names)
+    assert_equal(["ABC", "ABC::DEF", "ABC::Zzz", "ABC::DEF.bar", 
+                 "ABC::Zzz.foo", "ABC::Zzz#foo"], @index.all_names(0))
+    assert_equal(["ABC", "ABC::DEF", "ABC::DEF::Foo", "CDE", 
+                 "ABC::DEF::Foo#baz", "ABC::DEF::Foo#foo", "ABC::Zzz.foo",
+                 "CDE.foo"], @index.all_names(1))
+    assert_equal(["CDE", "FGH", "FGH::Adfdsf", "CDE.foo", "FGH::Adfdsf#foo"],
+                 @index.all_names(2))
+    assert_equal(["ABC", "ABC::DEF", "ABC::DEF::Foo", "CDE", 
+                 "ABC::DEF::Foo#baz", "ABC::DEF::Foo#foo", "ABC::Zzz.foo",
+                 "CDE.foo"], @index.all_names("somegem-0.1.0"))
+    assert_equal([], @index.all_names("notinstalled-1.0"))
+  end
+
+  def test_get_class_entry
+    assert_nil(@index.get_class_entry("NONEXISTENT_FOO"))
+    assert_equal("ABC", @index.get_class_entry("ABC", nil).full_name)
+    assert_nil(@index.get_class_entry("ABC", nil).source_index)
+    assert_nil(@index.get_class_entry("ABC::DEF::Foo", 0))
+    assert_equal(1, @index.get_class_entry("ABC::DEF::Foo", 1).source_index)
+    assert_equal(2, @index.get_class_entry("ABC::DEF::Foo", 1).index)
+  end
+
+  def test_get_method_entry
+    assert_equal("ABC::DEF.bar", @index.get_method_entry("ABC::DEF.bar", nil).full_name)
+    assert_equal(0, @index.get_method_entry("ABC::DEF.bar", 0).source_index)
+    assert_nil(@index.get_method_entry("FGH::Adfdsf#foo", 1))
+    assert_equal(6, @index.get_method_entry("FGH::Adfdsf#foo", 2).index)
+    assert_equal(2, @index.get_method_entry("FGH::Adfdsf#foo", 2).source_index)
+    assert_equal("FGH::Adfdsf#foo", @index.get_method_entry("FGH::Adfdsf#foo", 2).full_name)
+  end
+
+  def test_namespaces_under
+    assert_kind_of(Array, @index.namespaces_under("ABC", true, nil))
+    results = @index.namespaces_under("ABC", true, nil)
+    assert_equal(3, results.size)
+    assert_equal(["ABC::DEF", "ABC::DEF::Foo", "ABC::Zzz"], results.map{|x| x.full_name})
+    results = @index.namespaces_under("ABC", false, nil)
+    assert_equal(2, results.size)
+    assert_equal(["ABC::DEF", "ABC::Zzz"], results.map{|x| x.full_name})
+  end
+
+  def test_namespaces_under_scoped
+    results = @index.namespaces_under("ABC", false, 1)
+    assert_kind_of(Array, results)
+    assert_equal(["ABC::DEF"], results.map{|x| x.full_name})
+    results = @index.namespaces_under("ABC", true, 1)
+    assert_equal(2, results.size)
+    assert_equal(["ABC::DEF", "ABC::DEF::Foo"], results.map{|x| x.full_name})
+    results = @index.namespaces_under("ABC", true, "somegem-0.1.0")
+    assert_equal(2, results.size)
+    assert_equal(["ABC::DEF", "ABC::DEF::Foo"], results.map{|x| x.full_name})
+    results = @index.namespaces_under("ABC", true, 0)
+    assert_equal(2, results.size)
+    assert_equal(["ABC::DEF", "ABC::Zzz"], results.map{|x| x.full_name})
+  end
+
+  def test_namespaces_under_toplevel
+    toplevel = @index.top_level_namespace[0]
+    assert_equal(["ABC", "CDE", "FGH"], 
+                 @index.namespaces_under(toplevel, false, nil).map{|x| x.full_name})
+    assert_equal(["ABC", "ABC::DEF", "ABC::DEF::Foo", "ABC::Zzz", 
+                  "CDE", "FGH", "FGH::Adfdsf"], 
+                 @index.namespaces_under(toplevel, true, nil).map{|x| x.full_name})
+    assert_equal(["CDE", "FGH", "FGH::Adfdsf"], 
+                 @index.namespaces_under(toplevel, true, "stuff-1.1.0").map{|x| x.full_name})
+  end
+
+  def test_source_paths_for_string
+    assert_equal([], @index.source_paths_for(""))
+    assert_equal([], @index.source_paths_for(nil))
+
+    assert_equal(["/usr/share/ri/system/", "/long/path/somegem-0.1.0"], @index.source_paths_for("ABC::DEF"))
+    assert_equal(["/long/path/somegem-0.1.0", "/long/path/stuff-1.1.0"], @index.source_paths_for("CDE.foo"))
+  end
+
+  def test_source_paths_for_entry
+    assert_equal(["/usr/share/ri/system/", "/long/path/somegem-0.1.0"],
+                 @index.source_paths_for(@index.get_class_entry("ABC::DEF")))
+    assert_equal(["/long/path/somegem-0.1.0", "/long/path/stuff-1.1.0"],
+                 @index.source_paths_for(@index.get_method_entry("CDE.foo")))
+  end
+
+  def test_methods_under_same_prefix
+    results = @index2.methods_under("ABC", true, nil)
+    results.map{|x| x.full_name}
+    assert_equal(["ABC.bar", "ABC#baz"], results.map{|x| x.full_name})
+  end
+
+  def test_methods_under_scoped
+    results = @index.methods_under("ABC", true, 1)
+    assert_equal(["ABC::DEF::Foo#baz", "ABC::DEF::Foo#foo", "ABC::Zzz.foo"], results.map{|x| x.full_name})
+    results = @index.methods_under("CDE", false, "stuff-1.1.0")
+    assert_equal(["CDE.foo"], results.map{|x| x.full_name})
+    results = @index.methods_under("ABC", true, nil)
+    assert_equal(["ABC::DEF.bar", "ABC::DEF::Foo#baz", "ABC::DEF::Foo#foo", 
+                 "ABC::Zzz.foo", "ABC::Zzz#foo"], results.map{|x| x.full_name})
+    assert_equal(["ABC::DEF.bar", "ABC::DEF::Foo#baz", "ABC::DEF::Foo#foo", 
+                 "ABC::Zzz.foo", "ABC::Zzz#foo", "CDE.foo", "FGH::Adfdsf#foo"], 
+                 @index.methods_under("", true, nil).map{|x| x.full_name})
+    assert_equal([], @index.methods_under("ABC", false, nil).map{|x| x.full_name})
+    assert_equal(["CDE.foo"], 
+                 @index.methods_under("CDE", false, nil).map{|x| x.full_name})
+    assert_equal(["FGH::Adfdsf#foo"], 
+                 @index.methods_under("FGH", true, nil).map{|x| x.full_name})
+    assert_equal([], @index.methods_under("FGH", true, 0).map{|x| x.full_name})
+    assert_equal(["FGH::Adfdsf#foo"], 
+                 @index.methods_under("FGH", true, 2).map{|x| x.full_name})
+    assert_equal([], @index.methods_under("FGH", false, 2).map{|x| x.full_name})
+    assert_equal(["FGH::Adfdsf#foo"], 
+                 @index.methods_under("FGH::Adfdsf", false, 2).map{|x| x.full_name})
+    assert_equal(["FGH::Adfdsf#foo"], 
+                 @index.methods_under("FGH::Adfdsf", true, 2).map{|x| x.full_name})
+    assert_equal([], @index.methods_under("FGH::Adfdsf", false, 0).map{|x| x.full_name})
+  end
+
+  def test_lookup_namespace_in
+    toplevel = @index.top_level_namespace
+    res = @index.lookup_namespace_in("ABC", toplevel)
+    assert_equal(["ABC"], res.map{|x| x.full_name})
+    toplevel2 = @index.top_level_namespace(2)
+    assert_equal([], @index.lookup_namespace_in("ABC", toplevel2))
+    assert_equal(["FGH"], @index.lookup_namespace_in("FGH", toplevel2).map{|x| x.full_name})
+  end
+
+  def test_find_class_by_name
+    class_entry = nil
+    class << @index; self end.module_eval do
+      define_method(:get_class){|x| class_entry = x}
+    end
+    @index.find_class_by_name("ABC")
+    assert_kind_of(FastRI::RiIndex::ClassEntry, class_entry)
+    assert_equal("ABC", class_entry.full_name)
+    assert_nil(class_entry.source_index)
+    assert_equal(0, class_entry.index)
+    class_entry = nil
+    @index.find_class_by_name("ABC::DEF::Foo")
+    assert_kind_of(FastRI::RiIndex::ClassEntry, class_entry)
+    assert_equal("ABC::DEF::Foo", class_entry.full_name)
+    assert_nil(class_entry.source_index)
+    assert_equal(2, class_entry.index)
+    class_entry = nil
+    @index.find_class_by_name("ABC::DEF::Foo", 1)
+    assert_kind_of(FastRI::RiIndex::ClassEntry, class_entry)
+    assert_equal("ABC::DEF::Foo", class_entry.full_name)
+    assert_equal(1, class_entry.source_index)
+    assert_equal(2, class_entry.index)
+    class_entry = nil
+    @index.find_class_by_name("ABC::DEF::Foo", 0)
+    assert_nil(class_entry)
+    @index.find_class_by_name("AB", nil)
+    assert_nil(class_entry)
+  end
+
+  def test_find_method_by_name
+    method_entry = nil
+    class << @index; self end.module_eval do
+      define_method(:get_method){|x| method_entry = x}
+    end
+    @index.find_method_by_name("ABC")
+    assert_nil(method_entry)
+    @index.find_method_by_name("ABC::DEF.bar")
+    assert_equal("ABC::DEF.bar", method_entry.full_name)
+    method_entry = nil
+    @index.find_method_by_name("ABC::DEF::Foo#baz")
+    assert_equal("ABC::DEF::Foo#baz", method_entry.full_name)
+    assert_nil(method_entry.source_index)
+    assert_equal(1, method_entry.index)
+    method_entry = nil
+    @index.find_method_by_name("ABC::DEF::Foo#baz", 1)
+    assert_equal("ABC::DEF::Foo#baz", method_entry.full_name)
+    assert_equal(1, method_entry.source_index)
+    assert_equal(1, method_entry.index)
+    method_entry = nil
+    @index.find_method_by_name("CDE.foo", 2)
+    assert_equal("CDE.foo", method_entry.full_name)
+    assert_equal(5, method_entry.index)
+    assert_equal(2, method_entry.source_index)
+    method_entry = nil
+    @index.find_method_by_name("ABC::DEF::Foo#ba", 1)
+    assert_nil(method_entry)
+    @index.find_method_by_name("ABC::DEF.bar", 1)
+    assert_nil(method_entry)
+  end
+
+  def test_find_methods
+    toplevel = @index.top_level_namespace
+    assert_equal(["ABC::DEF::Foo#baz", "ABC::DEF::Foo#foo", 
+                  "ABC::Zzz#foo", "FGH::Adfdsf#foo"], 
+                 @index.find_methods("", false, toplevel).map{|x| x.full_name})
+    assert_equal(["ABC::DEF.bar", "ABC::Zzz.foo", "CDE.foo"], 
+                 @index.find_methods("", true, toplevel).map{|x| x.full_name})
+    assert_equal([], @index.find_methods("ABC", true, toplevel).map{|x| x.full_name})
+    assert_equal(["ABC::DEF::Foo#foo", "ABC::Zzz#foo", "FGH::Adfdsf#foo"], 
+                 @index.find_methods("foo", false, toplevel).map{|x| x.full_name})
+    assert_equal(["ABC::Zzz.foo", "CDE.foo"], 
+                 @index.find_methods("foo", true, toplevel).map{|x| x.full_name})
+    toplevel = @index.top_level_namespace(1)
+    assert_equal(["ABC::DEF::Foo#foo"], @index.find_methods("foo", false, toplevel).map{|x| x.full_name})
+    toplevel = @index.top_level_namespace("stuff-1.1.0")
+    assert_equal(["CDE.foo"], @index.find_methods("foo", true, toplevel).map{|x| x.full_name})
+  end
+
+  def test_num_namespaces
+    assert_equal(7, @index.num_namespaces)
+  end
+
+  def test_num_methods
+    assert_equal(7, @index.num_methods)
+  end
+
+  #{{{ ClassEntry and MethodEntry
+  def test_ClassEntry_contained_modules_matching
+    toplevel = @index.top_level_namespace[0]
+    assert_equal(["ABC"], toplevel.contained_modules_matching("ABC").map{|x| x.full_name})
+
+    class_entry = @index.get_class_entry("ABC")
+    assert_equal([], class_entry.contained_modules_matching("ABC").map{|x| x.full_name})
+    assert_equal(["ABC::DEF", "ABC::Zzz"], class_entry.contained_modules_matching("").map{|x| x.full_name})
+  end
+
+  def test_ClassEntry_type
+    class_entry = @index.get_class_entry("ABC")
+    assert_equal(:namespace, class_entry.type)
+  end
+
+  def test_ClassEntry_path_names
+    class_entry = @index.get_class_entry("ABC")
+    assert_equal(["/usr/share/ri/system/ABC", "/long/path/somegem-0.1.0/ABC"], class_entry.path_names)
+
+    class_entry = @index.get_class_entry("ABC", 0)
+    assert_equal(["/usr/share/ri/system/ABC"], class_entry.path_names)
+    class_entry = @index.get_class_entry("ABC", 1)
+    assert_equal(["/long/path/somegem-0.1.0/ABC"], class_entry.path_names)
+  end
+
+  def test_ClassEntry_classes_and_modules
+    class_entry = @index.get_class_entry("ABC")
+    assert_equal(["ABC::DEF", "ABC::Zzz"], 
+                 class_entry.classes_and_modules.map{|x| x.full_name})
+    class_entry = @index.get_class_entry("ABC::DEF")
+    assert_equal(["ABC::DEF::Foo"], class_entry.classes_and_modules.map{|x| x.full_name})
+  end
+
+  def test_ClassEntry_contained_class_named
+    class_entry = @index.get_class_entry("ABC")
+    class_entry = class_entry.contained_class_named("DEF")
+    assert_equal("ABC::DEF", class_entry.full_name)
+    assert_equal(1, class_entry.index)
+    class_entry = class_entry.contained_class_named("Foo")
+    assert_equal(2, class_entry.index)
+    assert_nil(class_entry.contained_class_named("Bar"))
+    assert_equal(3, @index.get_class_entry("ABC").contained_class_named("Zzz").index)
+  end
+
+  def test_ClassEntry_methods_matching
+    class_entry = @index.get_class_entry("ABC::Zzz")
+    assert_equal([], class_entry.methods_matching("nonexistent", false))
+    assert_equal([3], class_entry.methods_matching("foo", true).map{|x| x.index})
+    assert_equal([4], class_entry.methods_matching("foo", false).map{|x| x.index})
+  end
+
+  def test_ClassEntry_recursively_find_methods_matching
+    class_entry = @index.get_class_entry("ABC")
+    assert_equal(["ABC::DEF.bar", "ABC::Zzz.foo"], 
+                 class_entry.recursively_find_methods_matching(//, true).map{|x| x.full_name})
+    assert_equal(["ABC::DEF::Foo#baz", "ABC::DEF::Foo#foo", "ABC::Zzz#foo"], 
+                 class_entry.recursively_find_methods_matching(//, false).map{|x| x.full_name})
+    assert_equal([], class_entry.recursively_find_methods_matching(/nonono/, false).map{|x| x.full_name})
+  end
+
+  def test_ClassEntry_all_method_names
+    class_entry = @index.get_class_entry("ABC")
+    assert_equal([], class_entry.all_method_names)
+    class_entry = @index.get_class_entry("ABC::Zzz")
+    assert_equal(["ABC::Zzz.foo", "ABC::Zzz#foo"], class_entry.all_method_names)
+  end
+
+  def test_MethodEntry_path_name
+    method_entry = @index.get_method_entry("CDE.foo")
+    assert_equal("/long/path/somegem-0.1.0/CDE/foo-c.yaml", method_entry.path_name)
+
+    method_entry = @index.get_method_entry("CDE.foo", 1)
+    assert_equal("/long/path/somegem-0.1.0/CDE/foo-c.yaml", method_entry.path_name)
+    method_entry = @index.get_method_entry("CDE.foo", 2)
+    assert_equal("/long/path/stuff-1.1.0/CDE/foo-c.yaml", method_entry.path_name)
+  end
+
+  def test_MethodEntry_type
+    method_entry = @index.get_method_entry("CDE.foo")
+    assert_equal(:method, method_entry.type)
+  end
+end
+