ferret 0.9.6 → 0.10.0

data/test/unit/query_parser/tc_query_parser.rb

@@ -1,9 +1,11 @@
 require File.dirname(__FILE__) + "/../../test_helper"
 
 class QueryParserTest < Test::Unit::TestCase
+  include Ferret::Analysis
 
   def test_strings()
-    parser = Ferret::QueryParser.new("xxx", :fields => ["xxx", "field", "f1", "f2"])
+    parser = Ferret::QueryParser.new(:default_field => "xxx",
+                                     :fields => ["xxx", "field", "f1", "f2"])
     pairs = [
       ['', ''],
       ['*:word', 'word field:word f1:word f2:word'],
@@ -101,8 +103,9 @@ class QueryParserTest < Test::Unit::TestCase
   end
 
   def test_qp_with_standard_analyzer()
-    parser = Ferret::QueryParser.new("xxx", :fields => ["xxx", "key"],
-                                     :analyzer => Ferret::Analysis::StandardAnalyzer.new)
+    parser = Ferret::QueryParser.new(:default_field => "xxx",
+                                     :fields => ["xxx", "key"],
+                                     :analyzer => StandardAnalyzer.new)
     pairs = [
       ['key:1234', 'key:1234'],
       ['key:(1234 and Dave)', 'key:1234 key:dave'],
@@ -116,48 +119,51 @@ class QueryParserTest < Test::Unit::TestCase
 
   end
 
-  if not $ferret_pure_ruby
-    def test_qp_changing_fields()
-      parser = Ferret::QueryParser.new("xxx", :fields => ["xxx", "key"],
-                     :analyzer => Ferret::Analysis::WhiteSpaceAnalyzer.new)
-      assert_equal('word key:word', parser.parse("*:word").to_s("xxx"))
-
-      parser.fields = ["xxx", "one", "two", "three"]
-      assert_equal('word one:word two:word three:word',
-                   parser.parse("*:word").to_s("xxx"))
-      assert_equal('three:word four:word',
-                   parser.parse("three:word four:word").to_s("xxx"))
-    end
+  def test_qp_changing_fields()
+    parser = Ferret::QueryParser.new(:default_field => "xxx",
+                                     :fields => ["xxx", "key"],
+                                     :analyzer => WhiteSpaceAnalyzer.new)
+    assert_equal('word key:word', parser.parse("*:word").to_s("xxx"))
+
+    parser.fields = ["xxx", "one", "two", "three"]
+    assert_equal('word one:word two:word three:word',
+                 parser.parse("*:word").to_s("xxx"))
+    assert_equal('three:word four:word',
+                 parser.parse("three:word four:word").to_s("xxx"))
+  end
 
-    def test_qp_allow_any_field()
-      parser = Ferret::QueryParser.new("xxx", :fields => ["xxx", "key"],
-                     :analyzer => Ferret::Analysis::WhiteSpaceAnalyzer.new,
-                     :allow_any_fields => false)
+  def test_qp_allow_any_field()
+    parser = Ferret::QueryParser.new(:default_field => "xxx",
+                                     :fields => ["xxx", "key"],
+                                     :analyzer => WhiteSpaceAnalyzer.new,
+                                     :validate_fields => true)
 
-      assert_equal('key:word',
-                   parser.parse("key:word song:word").to_s("xxx"))
-      assert_equal('word key:word', parser.parse("*:word").to_s("xxx"))
+    assert_equal('key:word',
+                 parser.parse("key:word song:word").to_s("xxx"))
+    assert_equal('word key:word', parser.parse("*:word").to_s("xxx"))
 
 
-      parser = Ferret::QueryParser.new("xxx", :fields => ["xxx", "key"],
-                     :analyzer => Ferret::Analysis::WhiteSpaceAnalyzer.new)
+    parser = Ferret::QueryParser.new(:default_field => "xxx",
+                                     :fields => ["xxx", "key"],
+                                     :analyzer => WhiteSpaceAnalyzer.new)
 
-      assert_equal('key:word song:word',
-                   parser.parse("key:word song:word").to_s("xxx"))
-      assert_equal('word key:word song:word', parser.parse("*:word").to_s("xxx"))
-    end
+    assert_equal('key:word song:word',
+                 parser.parse("key:word song:word").to_s("xxx"))
+    assert_equal('word key:word', parser.parse("*:word").to_s("xxx"))
   end
   
   def do_test_query_parse_exception_raised(str)
-    parser = Ferret::QueryParser.new("xxx", :fields => ["f1", "f2", "f3"])
+    parser = Ferret::QueryParser.new(:default_field => "xxx",
+                                     :fields => ["f1", "f2", "f3"])
     assert_raise(Ferret::QueryParser::QueryParseException) do
       parser.parse(str)
     end
   end
 
   def test_prefix_query
-    parser = Ferret::QueryParser.new("xxx", :fields => ["xxx"],
-                   :analyzer => Ferret::Analysis::StandardAnalyzer.new)
+    parser = Ferret::QueryParser.new(:default_field => "xxx",
+                                     :fields => ["xxx"],
+                                     :analyzer => StandardAnalyzer.new)
     assert_equal(Ferret::Search::PrefixQuery, parser.parse("asdg*").class)
     assert_equal(Ferret::Search::WildcardQuery, parser.parse("a?dg*").class)
     assert_equal(Ferret::Search::WildcardQuery, parser.parse("a*dg*").class)
@@ -165,8 +171,9 @@ class QueryParserTest < Test::Unit::TestCase
   end
   
   def test_bad_queries
-    parser = Ferret::QueryParser.new("xxx", :fields => ["f1", "f2"],
-                                            :handle_parse_errors => true)
+    parser = Ferret::QueryParser.new(:default_field => "xxx",
+                                     :fields => ["f1", "f2"],
+                                     :handle_parse_errors => true)
 
     pairs = [
       ['::*word', 'word'],

data/test/unit/search/tc_filter.rb

@@ -2,37 +2,27 @@ require File.dirname(__FILE__) + "/../../test_helper"
 
 
 class FilterTest < Test::Unit::TestCase
-  include Ferret::Document
   include Ferret::Search
   include Ferret::Analysis
   include Ferret::Index
 
-  def add_doc(hash, writer)
-    doc = Document.new()
-    hash.each_pair do |field, text|
-      doc << Field.new(field, text, Field::Store::NO, Field::Index::UNTOKENIZED)
-    end
-    writer << doc
-  end
-
   def setup()
     @dir = Ferret::Store::RAMDirectory.new()
-    iw = IndexWriter.new(@dir,
+    iw = IndexWriter.new(:dir => @dir,
                          :analyzer => WhiteSpaceAnalyzer.new(),
                          :create => true)
-    docs = [ 
-      {"int"=>"0","date"=>"20040601","switch"=>"on"},
-      {"int"=>"1","date"=>"20041001","switch"=>"off"},
-      {"int"=>"2","date"=>"20051101","switch"=>"on"},
-      {"int"=>"3","date"=>"20041201","switch"=>"off"},
-      {"int"=>"4","date"=>"20051101","switch"=>"on"},
-      {"int"=>"5","date"=>"20041201","switch"=>"off"},
-      {"int"=>"6","date"=>"20050101","switch"=>"on"},
-      {"int"=>"7","date"=>"20040701","switch"=>"off"},
-      {"int"=>"8","date"=>"20050301","switch"=>"on"},
-      {"int"=>"9","date"=>"20050401","switch"=>"off"}
-    ]
-    docs.each {|doc| add_doc(doc, iw)}
+    [ 
+      {:int => "0", :date => "20040601", :switch => "on"},
+      {:int => "1", :date => "20041001", :switch => "off"},
+      {:int => "2", :date => "20051101", :switch => "on"},
+      {:int => "3", :date => "20041201", :switch => "off"},
+      {:int => "4", :date => "20051101", :switch => "on"},
+      {:int => "5", :date => "20041201", :switch => "off"},
+      {:int => "6", :date => "20050101", :switch => "on"},
+      {:int => "7", :date => "20040701", :switch => "off"},
+      {:int => "8", :date => "20050301", :switch => "on"},
+      {:int => "9", :date => "20050401", :switch => "off"}
+    ].each {|doc| iw << doc}
     iw.close
   end
 
@@ -40,74 +30,72 @@ class FilterTest < Test::Unit::TestCase
     @dir.close()
   end
 
-  def do_test_top_docs(is, query, expected, filter)
-    top_docs = is.search(query, {:filter => filter})
+  def do_test_top_docs(searcher, query, expected, filter)
+    top_docs = searcher.search(query, {:filter => filter})
     #puts top_docs
-    assert_equal(expected.size, top_docs.score_docs.size)
+    assert_equal(expected.size, top_docs.hits.size)
     top_docs.total_hits.times do |i|
-      assert_equal(expected[i], top_docs.score_docs[i].doc)
+      assert_equal(expected[i], top_docs.hits[i].doc)
+    end
+  end
+
+  def test_filter_proc
+    searcher = Searcher.new(@dir)
+    q = MatchAllQuery.new()
+    filter_proc = lambda {|doc, score, s| (s[doc][:int] % 2) == 0}
+    top_docs = searcher.search(q, :filter_proc => filter_proc)
+    top_docs.hits.each do |hit|
+      assert_equal(0, searcher[hit.doc][:int] % 2)
     end
   end
 
   def test_range_filter
-    is = IndexSearcher.new(@dir)
+    searcher = Searcher.new(@dir)
     q = MatchAllQuery.new()
-    rf = RangeFilter.new("int", "2", "6", true, true)
-    do_test_top_docs(is, q, [2,3,4,5,6], rf)
-    rf = RangeFilter.new("int", "2", "6", true, false)
-    do_test_top_docs(is, q, [2,3,4,5], rf)
-    rf = RangeFilter.new("int", "2", "6", false, true)
-    do_test_top_docs(is, q, [3,4,5,6], rf)
-    rf = RangeFilter.new("int", "2", "6", false, false)
-    do_test_top_docs(is, q, [3,4,5], rf)
-    rf = RangeFilter.new_more("int", "6")
-    do_test_top_docs(is, q, [6,7,8,9], rf)
-    rf = RangeFilter.new_more("int", "6", false)
-    do_test_top_docs(is, q, [7,8,9], rf)
-    rf = RangeFilter.new_less("int", "2")
-    do_test_top_docs(is, q, [0,1,2], rf)
-    rf = RangeFilter.new_less("int", "2", false)
-    do_test_top_docs(is, q, [0,1], rf)
+    rf = RangeFilter.new(:int, :>= => "2", :<= => "6")
+    do_test_top_docs(searcher, q, [2,3,4,5,6], rf)
+    rf = RangeFilter.new(:int, :>= => "2", :< => "6")
+    do_test_top_docs(searcher, q, [2,3,4,5], rf)
+    rf = RangeFilter.new(:int, :> => "2", :<= => "6")
+    do_test_top_docs(searcher, q, [3,4,5,6], rf)
+    rf = RangeFilter.new(:int, :> => "2", :< => "6")
+    do_test_top_docs(searcher, q, [3,4,5], rf)
+    rf = RangeFilter.new(:int, :>= => "6")
+    do_test_top_docs(searcher, q, [6,7,8,9], rf)
+    rf = RangeFilter.new(:int, :> => "6")
+    do_test_top_docs(searcher, q, [7,8,9], rf)
+    rf = RangeFilter.new(:int, :<= => "2")
+    do_test_top_docs(searcher, q, [0,1,2], rf)
+    rf = RangeFilter.new(:int, :< => "2")
+    do_test_top_docs(searcher, q, [0,1], rf)
   end
 
   def test_range_filter_errors
-    assert_raise(ArgumentError) {f = RangeFilter.new("", "asd", nil, false, true)}
-    assert_raise(ArgumentError) {f = RangeFilter.new("", nil, "asd", true, false)}
-    assert_raise(ArgumentError) {f = RangeFilter.new("", "ac", "ab", false, false)}
-    assert_raise(ArgumentError) {f = RangeFilter.new("", nil, nil, false, false)}
+    assert_raise(ArgumentError) {f = RangeFilter.new(:f, :> => "b", :< => "a")}
+    assert_raise(ArgumentError) {f = RangeFilter.new(:f, :include_lower => true)}
+    assert_raise(ArgumentError) {f = RangeFilter.new(:f, :include_upper => true)}
   end
 
   def test_query_filter()
-    is = IndexSearcher.new(@dir)
+    searcher = Searcher.new(@dir)
     q = MatchAllQuery.new()
-    qf = QueryFilter.new(TermQuery.new(Term.new("switch", "on")))
-    do_test_top_docs(is, q, [0,2,4,6,8], qf)
+    qf = QueryFilter.new(TermQuery.new(:switch, "on"))
+    do_test_top_docs(searcher, q, [0,2,4,6,8], qf)
     # test again to test caching doesn't break it
-    do_test_top_docs(is, q, [0,2,4,6,8], qf)
-    qf = QueryFilter.new(TermQuery.new(Term.new("switch", "off")))
-    do_test_top_docs(is, q, [1,3,5,7,9], qf)
+    do_test_top_docs(searcher, q, [0,2,4,6,8], qf)
+    qf = QueryFilter.new(TermQuery.new(:switch, "off"))
+    do_test_top_docs(searcher, q, [1,3,5,7,9], qf)
   end
 
   def test_filtered_query
-    is = IndexSearcher.new(@dir)
+    searcher = Searcher.new(@dir)
     q = MatchAllQuery.new()
-    rf = RangeFilter.new("int", "2", "6", true, true)
+    rf = RangeFilter.new(:int, :>= => "2", :<= => "6")
     rq = FilteredQuery.new(q, rf)
-    qf = QueryFilter.new(TermQuery.new(Term.new("switch", "on")))
-    do_test_top_docs(is, rq, [2,4,6], qf)
+    qf = QueryFilter.new(TermQuery.new(:switch, "on"))
+    do_test_top_docs(searcher, rq, [2,4,6], qf)
     query = FilteredQuery.new(rq, qf)
-    rf2 = RangeFilter.new_more("int", "3")
-    do_test_top_docs(is, query, [4,6], rf2)
+    rf2 = RangeFilter.new(:int, :>= => "3")
+    do_test_top_docs(searcher, query, [4,6], rf2)
   end
-  #def test_filtered_query
-  #  is = IndexSearcher.new(@dir)
-  #  q = MatchAllQuery.new()
-  #  rf = RangeFilter.new("int", "2", "6", true, true)
-  #  rq = FilteredQuery.new(q, rf)
-  #  qf = QueryFilter.new(TermQuery.new(Term.new("switch", "on")))
-  #  do_test_top_docs(is, rq, [2,4,6], qf)
-  #  query = FilteredQuery.new(rq, qf)
-  #  rf2 = RangeFilter.new_more("int", "3")
-  #  do_test_top_docs(is, query, [4,6], rf2)
-  #end
 end

data/test/unit/search/tc_fuzzy_query.rb

@@ -1,16 +1,13 @@
 require File.dirname(__FILE__) + "/../../test_helper"
 
 class FuzzyQueryTest < Test::Unit::TestCase
-  include Ferret::Document
   include Ferret::Search
   include Ferret::Store
   include Ferret::Analysis
   include Ferret::Index
 
   def add_doc(text, writer)
-    doc = Document.new()
-    doc << Field.new("field", text, Field::Store::NO, Field::Index::TOKENIZED)
-    writer << doc
+    writer << {:field => text}
   end
 
   def setup()
@@ -25,21 +22,23 @@ class FuzzyQueryTest < Test::Unit::TestCase
     top_docs = is.search(query)
     assert_equal(expected.length, top_docs.total_hits,
                 "expected #{expected.length} hits but got #{top_docs.total_hits}")
-    assert_equal(expected.length, top_docs.score_docs.size)
+    assert_equal(expected.length, top_docs.hits.size)
     top_docs.total_hits.times do |i|
-      assert_equal(expected[i], top_docs.score_docs[i].doc)
+      assert_equal(expected[i], top_docs.hits[i].doc)
     end
   end
 
   def do_prefix_test(is, text, prefix, expected)
-    fq = FuzzyQuery.new(Term.new("field", text), FuzzyQuery.default_min_similarity, prefix)
+    fq = FuzzyQuery.new(:field, text, :prefix_length => prefix)
     #puts is.explain(fq, 0)
     #puts is.explain(fq, 1)
     do_test_top_docs(is, fq, expected)
   end
 
   def test_fuzziness()
-    iw = IndexWriter.new(@dir, :analyzer => WhiteSpaceAnalyzer.new(), :create => true)
+    iw = IndexWriter.new(:dir => @dir,
+                         :analyzer => WhiteSpaceAnalyzer.new(),
+                         :create => true)
     add_doc("aaaaa", iw)
     add_doc("aaaab", iw)
     add_doc("aaabb", iw)
@@ -53,9 +52,9 @@ class FuzzyQueryTest < Test::Unit::TestCase
     iw.close()
 
 
-    is = IndexSearcher.new(@dir)
+    is = Searcher.new(@dir)
 
-    fq = FuzzyQuery.new(Term.new("field", "aaaaa"), FuzzyQuery.default_min_similarity, 5)
+    fq = FuzzyQuery.new(:field, "aaaaa", :prefix_length => 5)
 
     do_prefix_test(is, "aaaaaaaaaaaaaaaaaaaaaa", 1, [8])
     do_prefix_test(is, "aaaaa", 0, [0,1,2])
@@ -84,7 +83,7 @@ class FuzzyQueryTest < Test::Unit::TestCase
     do_prefix_test(is, "ddddX", 4, [6])
     do_prefix_test(is, "ddddX", 5, [])
     
-    fq = FuzzyQuery.new(Term.new("anotherfield", "ddddX"), FuzzyQuery.default_min_similarity, 0)
+    fq = FuzzyQuery.new(:anotherfield, "ddddX", :prefix_length => 0)
     top_docs = is.search(fq)
     assert_equal(0, top_docs.total_hits)
 
@@ -92,12 +91,14 @@ class FuzzyQueryTest < Test::Unit::TestCase
   end
 
   def test_fuzziness_long()
-    iw = IndexWriter.new(@dir, :analyzer => WhiteSpaceAnalyzer.new(), :create => true)
+    iw = IndexWriter.new(:dir => @dir,
+                         :analyzer => WhiteSpaceAnalyzer.new(),
+                         :create => true)
     add_doc("aaaaaaa", iw)
     add_doc("segment", iw)
     iw.optimize()
     iw.close()
-    is = IndexSearcher.new(@dir)
+    is = Searcher.new(@dir)
 
     # not similar enough:
     do_prefix_test(is, "xxxxx", 0, [])
@@ -126,12 +127,19 @@ class FuzzyQueryTest < Test::Unit::TestCase
     do_prefix_test(is, "stellent", 2, [])
 
     # "student" doesn't match anymore thanks to increased minimum similarity:
-    fq = FuzzyQuery.new(Term.new("field", "student"), 0.6, 0)
+    fq = FuzzyQuery.new(:field, "student",
+                        :min_similarity => 0.6,
+                        :prefix_length => 0)
+
     top_docs = is.search(fq)
     assert_equal(0, top_docs.total_hits)
 
-    assert_raise(ArgumentError) {fq = FuzzyQuery.new(Term.new("f", "s"), 1.1)}
-    assert_raise(ArgumentError) {fq = FuzzyQuery.new(Term.new("f", "s"), -0.1)}
+    assert_raise(ArgumentError) do
+      fq = FuzzyQuery.new(:f, "s", :min_similarity => 1.1)
+    end
+    assert_raise(ArgumentError) do
+      fq = FuzzyQuery.new(:f, "s", :min_similarity => -0.1)
+    end
 
     is.close()
   end

data/test/unit/search/tc_index_searcher.rb

@@ -1,237 +1,59 @@
 require File.dirname(__FILE__) + "/../../test_helper"
+require File.dirname(__FILE__) + "/tm_searcher"
 
-class IndexSearcherTest < Test::Unit::TestCase
-  include Ferret::Document
+class SearcherTest < Test::Unit::TestCase
   include Ferret::Search
   include Ferret::Store
   include Ferret::Analysis
   include Ferret::Index
 
+  include SearcherTests
+
   def setup()
     @dir = RAMDirectory.new()
-    iw = IndexWriter.new(@dir, :analyzer => WhiteSpaceAnalyzer.new(), :create => true)
-    @documents = IndexTestHelper.prepare_search_docs()
+    iw = IndexWriter.new(:dir => @dir,
+                         :analyzer => WhiteSpaceAnalyzer.new(),
+                         :create => true)
+    @documents = IndexTestHelper::SEARCH_TEST_DOCS
     @documents.each { |doc| iw << doc }
     iw.close()
-    @is = IndexSearcher.new(@dir)
+    @searcher = Searcher.new(@dir)
   end
 
   def tear_down()
-    @is.close
+    @searcher.close
     @dir.close()
   end
 
-  def get_docs(score_docs)
+  def get_docs(hits)
     docs = []
-    score_docs.each do |score_doc|
-      docs << score_doc.doc
+    hits.each do |hit|
+      docs << hit.doc
     end
     docs
   end
 
   def check_hits(query, expected, top=nil, total_hits=nil)
-    top_docs = @is.search(query)
-    assert_equal(expected.length, top_docs.score_docs.size)
-    assert_equal(top, top_docs.score_docs[0].doc) if top
+    top_docs = @searcher.search(query)
+    assert_equal(expected.length, top_docs.hits.size)
+    assert_equal(top, top_docs.hits[0].doc) if top
     if total_hits
       assert_equal(total_hits, top_docs.total_hits)
     else
       assert_equal(expected.length, top_docs.total_hits)
     end
-    top_docs.score_docs.each do |score_doc|
+    top_docs.hits.each do |score_doc|
       assert(expected.include?(score_doc.doc),
              "#{score_doc.doc} was found unexpectedly")
-      assert(score_doc.score =~ @is.explain(query, score_doc.doc).value, 
-        "Scores(#{score_doc.score} != #{@is.explain(query, score_doc.doc).value})")
-    end
-  end
-
-  def check_docs(query, options, expected=[])
-    top_docs = @is.search(query, options)
-    docs = top_docs.score_docs
-    assert_equal(expected.length, docs.length)
-    docs.length.times do |i|
-      assert_equal(expected[i], docs[i].doc)
+      assert(score_doc.score =~ @searcher.explain(query, score_doc.doc).score, 
+        "Scores(#{score_doc.score} != #{@searcher.explain(query, score_doc.doc).score})")
     end
   end
 
   def test_get_doc()
-    assert_equal(18, @is.max_doc)
-    assert_equal("20050930", @is.doc(0).values(:date))
-    assert_equal("cat1/sub2/subsub2", @is.doc(4)[:cat])
-    assert_equal("20051012", @is.doc(12)[:date])
-  end
-
-  def test_term_query
-    tq = TermQuery.new(Term.new("field", "word2"))
-    tq.boost = 100
-    check_hits(tq, [1,4,8])
-    #puts @is.explain(tq, 1)
-    #puts @is.explain(tq, 4)
-    #puts @is.explain(tq, 8)
-
-    tq = TermQuery.new(Term.new("field", "2342"))
-    check_hits(tq, [])
-
-    tq = TermQuery.new(Term.new("field", ""))
-    check_hits(tq, [])
-
-    tq = TermQuery.new(Term.new("field", "word1"))
-    top_docs = @is.search(tq)
-    assert_equal(@documents.size, top_docs.total_hits)
-    assert_equal(10, top_docs.score_docs.size)
-    top_docs = @is.search(tq, {:num_docs => 20})
-    assert_equal(@documents.size, top_docs.score_docs.size)
-  end
-
-
-  def test_first_doc
-    tq = TermQuery.new(Term.new("field", "word1"))
-    tq.boost = 100
-    top_docs = @is.search(tq, {:num_docs => 100})
-    expected = []
-    top_docs.score_docs.each do |sd|
-      expected << sd.doc
-    end
-
-    assert_raise(ArgumentError) { @is.search(tq, {:first_doc => -1}) }
-    assert_raise(ArgumentError) { @is.search(tq, {:num_docs => 0}) }
-    assert_raise(ArgumentError) { @is.search(tq, {:num_docs => -1}) }
-
-    check_docs(tq, {:num_docs => 8, :first_doc => 0}, expected[0,8])
-    check_docs(tq, {:num_docs => 3, :first_doc => 1}, expected[1,3])
-    check_docs(tq, {:num_docs => 6, :first_doc => 2}, expected[2,6])
-    check_docs(tq, {:num_docs => 2, :first_doc => expected.length}, [])
-    check_docs(tq, {:num_docs => 2, :first_doc => expected.length + 100}, [])
-  end
-
-  def test_boolean_query
-    bq = BooleanQuery.new()
-    tq1 = TermQuery.new(Term.new("field", "word1"))
-    tq2 = TermQuery.new(Term.new("field", "word3"))
-    bq.add_query(tq1, BooleanClause::Occur::MUST)
-    bq.add_query(tq2, BooleanClause::Occur::MUST)
-    check_hits(bq, [2,3,6,8,11,14], 14)
-
-    tq3 = TermQuery.new(Term.new("field", "word2"))
-    bq.add_query(tq3, BooleanClause::Occur::SHOULD)
-    check_hits(bq, [2,3,6,8,11,14], 8)
-
-    bq = BooleanQuery.new()
-    bq.add_query(tq2, BooleanClause::Occur::MUST)
-    bq.add_query(tq3, BooleanClause::Occur::MUST_NOT)
-    check_hits(bq, [2,3,6,11,14])
-
-    bq = BooleanQuery.new()
-    bq.add_query(tq2, BooleanClause::Occur::MUST_NOT)
-    check_hits(bq, [])
-
-    bq = BooleanQuery.new()
-    bq.add_query(tq2, BooleanClause::Occur::SHOULD)
-    bq.add_query(tq3, BooleanClause::Occur::SHOULD)
-    check_hits(bq, [1,2,3,4,6,8,11,14])
-
-    bq = BooleanQuery.new()
-    bc1 = BooleanClause.new(tq2, BooleanClause::Occur::SHOULD)
-    bc2 = BooleanClause.new(tq3, BooleanClause::Occur::SHOULD)
-    bq.add_clause(bc1)
-    bq.add_clause(bc2)
-    check_hits(bq, [1,2,3,4,6,8,11,14])
-  end
-
-  def test_phrase_query()
-    pq = PhraseQuery.new()
-    t1 = Term.new("field", "quick")
-    t2 = Term.new("field", "brown")
-    t3 = Term.new("field", "fox")
-    pq << t1 << t2 << t3
-    check_hits(pq, [1])
-
-    pq = PhraseQuery.new()
-    pq << t1
-    pq.add(t3, 2)
-    check_hits(pq, [1,11,14])
-
-    pq.slop = 1
-    check_hits(pq, [1,11,14,16])
-
-    pq.slop = 4
-    check_hits(pq, [1,11,14,16,17])
-  end
-
-  def test_range_query()
-    rq = RangeQuery.new("date", "20051006", "20051010", true, true)
-    check_hits(rq, [6,7,8,9,10])
-
-    rq = RangeQuery.new("date", "20051006", "20051010", false, true)
-    check_hits(rq, [7,8,9,10])
-
-    rq = RangeQuery.new("date", "20051006", "20051010", true, false)
-    check_hits(rq, [6,7,8,9])
-
-    rq = RangeQuery.new("date", "20051006", "20051010", false, false)
-    check_hits(rq, [7,8,9])
-
-    rq = RangeQuery.new("date", nil, "20051003", false, true)
-    check_hits(rq, [0,1,2,3])
-
-    rq = RangeQuery.new("date", nil, "20051003", false, false)
-    check_hits(rq, [0,1,2])
-
-    rq = RangeQuery.new_less("date", "20051003", true)
-    check_hits(rq, [0,1,2,3])
-
-    rq = RangeQuery.new_less("date", "20051003", false)
-    check_hits(rq, [0,1,2])
-
-    rq = RangeQuery.new("date", "20051014", nil, true, false)
-    check_hits(rq, [14,15,16,17])
-
-    rq = RangeQuery.new("date", "20051014", nil, false, false)
-    check_hits(rq, [15,16,17])
-
-    rq = RangeQuery.new_more("date", "20051014", true)
-    check_hits(rq, [14,15,16,17])
-
-    rq = RangeQuery.new_more("date", "20051014", false)
-    check_hits(rq, [15,16,17])
-  end
-
-  def test_prefix_query()
-    t = Term.new("cat", "cat1")
-    pq = PrefixQuery.new(t)
-    check_hits(pq, [0, 1, 2, 3, 4, 13, 14, 15, 16, 17])
-
-    t.text = "cat1/sub2"
-    pq = PrefixQuery.new(t)
-    check_hits(pq, [3, 4, 13, 15])
-  end
-
-  def test_wildcard_query()
-    t = Term.new("cat", "cat1*")
-    wq = WildcardQuery.new(t)
-    check_hits(wq, [0, 1, 2, 3, 4, 13, 14, 15, 16, 17])
-
-    t.text = "cat1*/su??ub2"
-    wq = WildcardQuery.new(t)
-    check_hits(wq, [4, 16])
-  end
-
-  def test_multi_phrase_query()
-    t11 = Term.new("field", "quick")
-    t12 = Term.new("field", "fast")
-    t21 = Term.new("field", "brown")
-    t22 = Term.new("field", "red")
-    t23 = Term.new("field", "hairy")
-    t3 = Term.new("field", "fox")
-
-    mpq = MultiPhraseQuery.new()
-    mpq << [t11, t12]
-    mpq << [t21, t22, t23]
-    mpq << t3
-    check_hits(mpq, [1, 8, 11, 14])
-
-    mpq.slop = 4
-    check_hits(mpq, [1, 8, 11, 14, 16, 17])
+    assert_equal(18, @searcher.max_doc)
+    assert_equal("20050930", @searcher.get_document(0)[:date])
+    assert_equal("cat1/sub2/subsub2", @searcher.get_document(4)[:category])
+    assert_equal("20051012", @searcher.get_document(12)[:date])
   end
 end