ferret 0.9.6 → 0.10.0

data/test/unit/search/tc_sort.rb

@@ -6,44 +6,44 @@ class SortTest < Test::Unit::TestCase
   def test_basic()
     s = Sort::RELEVANCE
     assert_equal(2, s.fields.size)
-    assert_equal(SortField::FIELD_SCORE, s.fields[0])
-    assert_equal(SortField::FIELD_DOC, s.fields[1])
+    assert_equal(SortField::SCORE, s.fields[0])
+    assert_equal(SortField::DOC_ID, s.fields[1])
 
     s = Sort::INDEX_ORDER
     assert_equal(1, s.fields.size)
-    assert_equal(SortField::FIELD_DOC, s.fields[0])
+    assert_equal(SortField::DOC_ID, s.fields[0])
   end
 
   def test_string_init()
-    s = Sort.new("field")
+    s = Sort.new(:field)
     assert_equal(2, s.fields.size)
-    assert_equal(SortField::SortType::AUTO, s.fields[0].sort_type)
-    assert_equal("field", s.fields[0].name)
-    assert_equal(SortField::FIELD_DOC, s.fields[1])
+    assert_equal(:auto, s.fields[0].type)
+    assert_equal(:field, s.fields[0].name)
+    assert_equal(SortField::DOC_ID, s.fields[1])
 
-    s = Sort.new(["field1", "field2", "field3"])
+    s = Sort.new([:field1, :field2, :field3])
     assert_equal(4, s.fields.size)
-    assert_equal(SortField::SortType::AUTO, s.fields[0].sort_type)
-    assert_equal("field1", s.fields[0].name)
-    assert_equal(SortField::SortType::AUTO, s.fields[1].sort_type)
-    assert_equal("field2", s.fields[1].name)
-    assert_equal(SortField::SortType::AUTO, s.fields[2].sort_type)
-    assert_equal("field3", s.fields[2].name)
-    assert_equal(SortField::FIELD_DOC, s.fields[3])
+    assert_equal(:auto, s.fields[0].type)
+    assert_equal(:field1, s.fields[0].name)
+    assert_equal(:auto, s.fields[1].type)
+    assert_equal(:field2, s.fields[1].name)
+    assert_equal(:auto, s.fields[2].type)
+    assert_equal(:field3, s.fields[2].name)
+    assert_equal(SortField::DOC_ID, s.fields[3])
   end
 
   def test_multi_fields()
-    sf1 = SortField.new("field", {:sort_type => SortField::SortType::INTEGER,
-                                  :reverse => true})
-    sf2 = SortField::FIELD_SCORE
-    sf3 = SortField::FIELD_DOC
+    sf1 = SortField.new(:field, {:type => :integer,
+                                 :reverse => true})
+    sf2 = SortField::SCORE
+    sf3 = SortField::DOC_ID
     s = Sort.new([sf1, sf2, sf3])
 
     assert_equal(3, s.fields.size)
-    assert_equal(SortField::SortType::INTEGER, s.fields[0].sort_type)
-    assert_equal("field", s.fields[0].name)
+    assert_equal(:integer, s.fields[0].type)
+    assert_equal(:field, s.fields[0].name)
     assert(s.fields[0].reverse?)
-    assert_equal(SortField::FIELD_SCORE, s.fields[1])
-    assert_equal(SortField::FIELD_DOC, s.fields[2])
+    assert_equal(SortField::SCORE, s.fields[1])
+    assert_equal(SortField::DOC_ID, s.fields[2])
   end
 end

data/test/unit/search/tc_sort_field.rb

@@ -4,24 +4,24 @@ class SortFieldTest < Test::Unit::TestCase
   include Ferret::Search
 
   def test_field_score()
-    fs = SortField::FIELD_SCORE
-    assert_equal(SortField::SortType::SCORE, fs.sort_type)
+    fs = SortField::SCORE
+    assert_equal(:score, fs.type)
     assert_nil(fs.name)
-    assert(!fs.reverse?, "FIELD_SCORE should not be reverse")
+    assert(!fs.reverse?, "SCORE_ID should not be reverse")
     assert_nil(fs.comparator)
   end
 
   def test_field_doc()
-    fs = SortField::FIELD_DOC
-    assert_equal(SortField::SortType::DOC, fs.sort_type)
+    fs = SortField::DOC_ID
+    assert_equal(:doc_id, fs.type)
     assert_nil(fs.name)
-    assert(!fs.reverse?, "FIELD_DOC should not be reverse")
+    assert(!fs.reverse?, "DOC_ID should be reverse")
     assert_nil(fs.comparator)
   end
 
   def test_error_raised()
     assert_raise(ArgumentError) {
-      fs = SortField.new(nil, {:sort_type => SortField::SortType::INTEGER})
+      fs = SortField.new(nil, :type => :integer)
     }
   end
 end

data/test/unit/search/tc_spans.rb

@@ -2,7 +2,6 @@ require File.dirname(__FILE__) + "/../../test_helper"
 
 
 class SpansBasicTest < Test::Unit::TestCase
-  include Ferret::Document
   include Ferret::Search
   include Ferret::Store
   include Ferret::Index
@@ -10,7 +9,11 @@ class SpansBasicTest < Test::Unit::TestCase
   include Ferret::Analysis
 
   def setup()
-    data = [
+    @dir = RAMDirectory.new
+    iw = IndexWriter.new(:dir => @dir,
+                         :analyzer => WhiteSpaceAnalyzer.new(),
+                         :create => true)
+    [
       "start finish one two three four five six seven",
       "start one finish two three four five six seven",
       "start one two finish three four five six seven",
@@ -42,22 +45,15 @@ class SpansBasicTest < Test::Unit::TestCase
       "finish one two start three four five six seven",
       "finish one start two three four five six seven",
       "finish start one two three four five six seven"
-    ]
-    @dir = RAMDirectory.new
-    iw = IndexWriter.new(@dir, :analyzer => WhiteSpaceAnalyzer.new(), :create => true)
-    data.each do |line|
-      doc = Document.new()
-      doc << Field.new("field", line, Field::Store::NO, Field::Index::TOKENIZED)
-      iw << doc
-    end
+    ].each { |line| iw << {:field => line} }
 
     iw.close()
 
-    @is = IndexSearcher.new(@dir)
+    @searcher = Searcher.new(@dir)
   end
 
   def tear_down()
-    @iw.close
+    @searcher.close
     @dir.close
   end
 
@@ -72,65 +68,72 @@ class SpansBasicTest < Test::Unit::TestCase
   end
 
   def check_hits(query, expected, test_explain = false, top=nil)
-    top_docs = @is.search(query, {:num_docs => expected.length})
-    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, {:limit => expected.length})
+    assert_equal(expected.length, top_docs.hits.size)
+    assert_equal(top, top_docs.hits[0].doc) if top
     assert_equal(expected.length, top_docs.total_hits)
-    top_docs.score_docs.each do |score_doc|
-      assert(expected.include?(score_doc.doc),
-             "#{score_doc.doc} was found unexpectedly")
+    top_docs.hits.each do |hit|
+      assert(expected.include?(hit.doc),
+             "#{hit.doc} was found unexpectedly")
       if test_explain
-        assert(score_doc.score =~ @is.explain(query, score_doc.doc).value, 
-          "Scores(#{score_doc.score} != #{@is.explain(query, score_doc.doc).value})")
+        assert(hit.score =~ @searcher.explain(query, hit.doc).score, 
+          "Scores(#{hit.score} != " +
+          "#{@searcher.explain(query, hit.doc).score})")
       end
     end
   end
 
   def test_span_term_query()
-    tq = SpanTermQuery.new(Term.new("field", "nine"))
+    tq = SpanTermQuery.new(:field, "nine")
     check_hits(tq, [7,23], true)
-    tq = SpanTermQuery.new(Term.new("field", "eight"))
+    tq = SpanTermQuery.new(:field, "eight")
     check_hits(tq, [6,7,8,22,23,24])
   end
 
   def test_span_near_query()
-    tq1 = SpanTermQuery.new(Term.new("field", "start"))
-    tq2 = SpanTermQuery.new(Term.new("field", "finish"))
-    q = SpanNearQuery.new([tq1, tq2], 0, true)
+    tq1 = SpanTermQuery.new(:field, "start")
+    tq2 = SpanTermQuery.new(:field, "finish")
+    q = SpanNearQuery.new(:clauses => [tq1, tq2], :in_order => true)
     check_hits(q, [0,14], true)
-    q = SpanNearQuery.new([tq1, tq2], 0, false)
+    q = SpanNearQuery.new()
+    q << tq1 << tq2
     check_hits(q, [0,14,16,30], true)
-    q = SpanNearQuery.new([tq1, tq2], 1, true)
+    q = SpanNearQuery.new(:clauses => [tq1, tq2],
+                          :slop => 1, :in_order => true)
     check_hits(q, [0,1,13,14])
-    q = SpanNearQuery.new([tq1, tq2], 1, false)
+    q = SpanNearQuery.new(:clauses => [tq1, tq2], :slop => 1)
     check_hits(q, [0,1,13,14,16,17,29,30])
-    q = SpanNearQuery.new([tq1, tq2], 4, true)
+    q = SpanNearQuery.new(:clauses => [tq1, tq2],
+                          :slop => 4, :in_order => true)
     check_hits(q, [0,1,2,3,4,10,11,12,13,14])
-    q = SpanNearQuery.new([tq1, tq2], 4, false)
+    q = SpanNearQuery.new(:clauses => [tq1, tq2], :slop => 4)
     check_hits(q, [0,1,2,3,4,10,11,12,13,14,16,17,18,19,20,26,27,28,29,30])
   end
 
   def test_span_not_query()
-    tq1 = SpanTermQuery.new(Term.new("field", "start"))
-    tq2 = SpanTermQuery.new(Term.new("field", "finish"))
-    tq3 = SpanTermQuery.new(Term.new("field", "two"))
-    tq4 = SpanTermQuery.new(Term.new("field", "five"))
-    nearq1 = SpanNearQuery.new([tq1, tq2], 4, true)
-    nearq2 = SpanNearQuery.new([tq3, tq4], 4, true)
+    tq1 = SpanTermQuery.new(:field, "start")
+    tq2 = SpanTermQuery.new(:field, "finish")
+    tq3 = SpanTermQuery.new(:field, "two")
+    tq4 = SpanTermQuery.new(:field, "five")
+    nearq1 = SpanNearQuery.new(:clauses => [tq1, tq2],
+                               :slop => 4, :in_order => true)
+    nearq2 = SpanNearQuery.new(:clauses => [tq3, tq4],
+                               :slop => 4, :in_order => true)
     q = SpanNotQuery.new(nearq1, nearq2)
     check_hits(q, [0,1,13,14], true)
-    nearq1 = SpanNearQuery.new([tq1, tq2], 4, false)
+    nearq1 = SpanNearQuery.new(:clauses => [tq1, tq2], :slop => 4)
     q = SpanNotQuery.new(nearq1, nearq2)
     check_hits(q, [0,1,13,14,16,17,29,30])
-    nearq1 = SpanNearQuery.new([tq1, tq3], 4, true)
-    nearq2 = SpanNearQuery.new([tq2, tq4], 8, false)
+    nearq1 = SpanNearQuery.new(:clauses => [tq1, tq3],
+                               :slop => 4, :in_order => true)
+    nearq2 = SpanNearQuery.new(:clauses => [tq2, tq4], :slop => 8)
     q = SpanNotQuery.new(nearq1, nearq2)
     check_hits(q, [2,3,4,5,6,7,8,9,10,11,12,15])
   end
 
   def test_span_first_query()
     finish_first = [16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
-    tq = SpanTermQuery.new(Term.new("field", "finish"))
+    tq = SpanTermQuery.new(:field, "finish")
     q = SpanFirstQuery.new(tq, 1)
     check_hits(q, finish_first, true)
     q = SpanFirstQuery.new(tq, 5)
@@ -138,15 +141,16 @@ class SpansBasicTest < Test::Unit::TestCase
   end
 
   def test_span_or_query_query()
-    tq1 = SpanTermQuery.new(Term.new("field", "start"))
-    tq2 = SpanTermQuery.new(Term.new("field", "finish"))
-    tq3 = SpanTermQuery.new(Term.new("field", "five"))
-    nearq1 = SpanNearQuery.new([tq1, tq2], 1, true)
-    nearq2 = SpanNearQuery.new([tq2, tq3], 0, false)
+    tq1 = SpanTermQuery.new(:field, "start")
+    tq2 = SpanTermQuery.new(:field, "finish")
+    tq3 = SpanTermQuery.new(:field, "five")
+    nearq1 = SpanNearQuery.new(:clauses => [tq1, tq2], :slop => 1,
+                               :in_order => true)
+    nearq2 = SpanNearQuery.new(:clauses => [tq2, tq3], :slop => 0)
     q = SpanOrQuery.new([nearq1, nearq2])
     check_hits(q, [0,1,4,5,9,10,13,14], false)
-    nearq1 = SpanNearQuery.new([tq1, tq2], 0, false)
-    nearq2 = SpanNearQuery.new([tq2, tq3], 1, false)
+    nearq1 = SpanNearQuery.new(:clauses => [tq1, tq2], :slop => 0)
+    nearq2 = SpanNearQuery.new(:clauses => [tq2, tq3], :slop => 1)
     q = SpanOrQuery.new([nearq1, nearq2])
     check_hits(q, [0,3,4,5,6,8,9,10,11,14,16,30], false)
   end

data/test/unit/search/tm_searcher.rb

@@ -0,0 +1,339 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+module SearcherTests
+  include Ferret::Search
+
+  def test_term_query
+    tq = TermQuery.new(:field, "word2")
+    tq.boost = 100
+    check_hits(tq, [1,4,8])
+    #puts @searcher.explain(tq, 1)
+    #puts @searcher.explain(tq, 4)
+    #puts @searcher.explain(tq, 8)
+
+    tq = TermQuery.new(:field, "2342")
+    check_hits(tq, [])
+
+    tq = TermQuery.new(:field, "")
+    check_hits(tq, [])
+
+    tq = TermQuery.new(:field, "word1")
+    top_docs = @searcher.search(tq)
+    assert_equal(@searcher.max_doc, top_docs.total_hits)
+    assert_equal(10, top_docs.hits.size)
+    top_docs = @searcher.search(tq, {:limit => 20})
+    assert_equal(@searcher.max_doc, top_docs.hits.size)
+  end
+
+  def check_docs(query, options, expected=[])
+    top_docs = @searcher.search(query, options)
+    docs = top_docs.hits
+    assert_equal(expected.length, docs.length)
+    docs.length.times do |i|
+      assert_equal(expected[i], docs[i].doc)
+    end
+  end
+
+  def test_offset
+    tq = TermQuery.new(:field, "word1")
+    tq.boost = 100
+    top_docs = @searcher.search(tq, {:limit => 100})
+    expected = []
+    top_docs.hits.each do |sd|
+      expected << sd.doc
+    end
+
+    assert_raise(ArgumentError) { @searcher.search(tq, {:offset => -1}) }
+    assert_raise(ArgumentError) { @searcher.search(tq, {:limit => 0}) }
+    assert_raise(ArgumentError) { @searcher.search(tq, {:limit => -1}) }
+
+    check_docs(tq, {:limit => 8, :offset => 0}, expected[0,8])
+    check_docs(tq, {:limit => 3, :offset => 1}, expected[1,3])
+    check_docs(tq, {:limit => 6, :offset => 2}, expected[2,6])
+    check_docs(tq, {:limit => 2, :offset => expected.length}, [])
+    check_docs(tq, {:limit => 2, :offset => expected.length + 100}, [])
+  end
+
+  def test_multi_term_query
+    mtq = MultiTermQuery.new(:field, :max_terms => 4, :min_score => 0.5)
+    check_hits(mtq, [])
+    assert_equal("<>", mtq.to_s(:field))
+    assert_equal("field:<>", mtq.to_s())
+
+    [
+      ["brown", 1.0, "<brown>"],
+      ["fox",   0.1, "<brown>"],
+      ["fox",   0.6, "<fox^0.6|brown>"],
+      ["fast", 50.0, "<fox^0.6|brown|fast^50.0>"]
+    ].each do |term, boost, str|
+      mtq.add_term(term, boost)
+      assert_equal(str, mtq.to_s(:field))
+      assert_equal("field:#{str}", mtq.to_s())
+    end
+
+    mtq.boost = 80.1
+    assert_equal("field:<fox^0.6|brown|fast^50.0>^80.1", mtq.to_s())
+    mtq << "word1"
+    assert_equal("field:<fox^0.6|brown|word1|fast^50.0>^80.1", mtq.to_s())
+    mtq << "word2"
+    assert_equal("field:<brown|word1|word2|fast^50.0>^80.1", mtq.to_s())
+    mtq << "word3"
+    assert_equal("field:<brown|word1|word2|fast^50.0>^80.1", mtq.to_s())
+  end
+
+  def test_boolean_query
+    bq = BooleanQuery.new()
+    tq1 = TermQuery.new(:field, "word1")
+    tq2 = TermQuery.new(:field, "word3")
+    bq.add_query(tq1, :must)
+    bq.add_query(tq2, :must)
+    check_hits(bq, [2,3,6,8,11,14], 14)
+
+    tq3 = TermQuery.new(:field, "word2")
+    bq.add_query(tq3, :should)
+    check_hits(bq, [2,3,6,8,11,14], 8)
+
+    bq = BooleanQuery.new()
+    bq.add_query(tq2, :must)
+    bq.add_query(tq3, :must_not)
+    check_hits(bq, [2,3,6,11,14])
+
+    bq = BooleanQuery.new()
+    bq.add_query(tq2, :must_not)
+    check_hits(bq, [])
+
+    bq = BooleanQuery.new()
+    bq.add_query(tq2, :should)
+    bq.add_query(tq3, :should)
+    check_hits(bq, [1,2,3,4,6,8,11,14])
+
+    bq = BooleanQuery.new()
+    bc1 = BooleanQuery::BooleanClause.new(tq2, :should)
+    bc2 = BooleanQuery::BooleanClause.new(tq3, :should)
+    bq << bc1
+    bq << bc2
+    check_hits(bq, [1,2,3,4,6,8,11,14])
+  end
+
+  def test_phrase_query()
+    pq = PhraseQuery.new(:field)
+    pq << "quick" << "brown" << "fox"
+    check_hits(pq, [1])
+
+    pq = PhraseQuery.new(:field)
+    pq << "quick"
+    pq.add_term("fox", 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, :lower => "20051006", :upper => "20051010")
+    check_hits(rq, [6,7,8,9,10])
+
+    rq = RangeQuery.new(:date, :>= => "20051006", :<= => "20051010")
+    check_hits(rq, [6,7,8,9,10])
+
+    rq = RangeQuery.new(:date, :lower => "20051006", :upper => "20051010",
+                        :include_lower => false)
+    check_hits(rq, [7,8,9,10])
+
+    rq = RangeQuery.new(:date, :> => "20051006", :<= => "20051010")
+    check_hits(rq, [7,8,9,10])
+
+    rq = RangeQuery.new(:date, :lower => "20051006", :upper => "20051010",
+                        :include_upper => false)
+    check_hits(rq, [6,7,8,9])
+
+    rq = RangeQuery.new(:date, :>= => "20051006", :< => "20051010")
+    check_hits(rq, [6,7,8,9])
+
+    rq = RangeQuery.new(:date, :lower => "20051006", :upper => "20051010",
+                        :include_lower => false, :include_upper => false)
+    check_hits(rq, [7,8,9])
+
+    rq = RangeQuery.new(:date, :> => "20051006", :< => "20051010")
+    check_hits(rq, [7,8,9])
+
+    rq = RangeQuery.new(:date, :upper => "20051003")
+    check_hits(rq, [0,1,2,3])
+
+    rq = RangeQuery.new(:date, :<= => "20051003")
+    check_hits(rq, [0,1,2,3])
+
+    rq = RangeQuery.new(:date, :upper => "20051003", :include_upper => false)
+    check_hits(rq, [0,1,2])
+
+    rq = RangeQuery.new(:date, :< => "20051003")
+    check_hits(rq, [0,1,2])
+
+    rq = RangeQuery.new(:date, :lower => "20051014")
+    check_hits(rq, [14,15,16,17])
+
+    rq = RangeQuery.new(:date, :>= => "20051014")
+    check_hits(rq, [14,15,16,17])
+
+    rq = RangeQuery.new(:date, :lower => "20051014", :include_lower => false)
+    check_hits(rq, [15,16,17])
+
+    rq = RangeQuery.new(:date, :> => "20051014")
+    check_hits(rq, [15,16,17])
+  end
+
+  def test_prefix_query()
+    pq = PrefixQuery.new(:category, "cat1")
+    check_hits(pq, [0, 1, 2, 3, 4, 13, 14, 15, 16, 17])
+
+    pq = PrefixQuery.new(:category, "cat1/sub2")
+    check_hits(pq, [3, 4, 13, 15])
+  end
+
+  def test_wildcard_query()
+    wq = WildcardQuery.new(:category, "cat1*")
+    check_hits(wq, [0, 1, 2, 3, 4, 13, 14, 15, 16, 17])
+
+    wq = WildcardQuery.new(:category, "cat1*/su??ub2")
+    check_hits(wq, [4, 16])
+  end
+
+  def test_multi_phrase_query()
+    mpq = PhraseQuery.new(:field)
+    mpq << ["quick", "fast"]
+    mpq << ["brown", "red", "hairy"]
+    mpq << "fox"
+    check_hits(mpq, [1, 8, 11, 14])
+
+    mpq.slop = 4
+    check_hits(mpq, [1, 8, 11, 14, 16, 17])
+  end
+
+  def test_highlighter()
+    dir = Ferret::Store::RAMDirectory.new
+    iw = Ferret::Index::IndexWriter.new(:dir => dir,
+                  :analyzer => Ferret::Analysis::WhiteSpaceAnalyzer.new())
+    [
+      {:field => "the words we are searching for are one and two also " +
+                 "sometimes looking for them as a phrase like this; one " +
+                 "two lets see how it goes"}
+    ].each {|doc| iw << doc }
+    iw.close
+    
+    searcher = Searcher.new(dir)
+
+    q = TermQuery.new(:field, "one");
+    highlights = searcher.highlight(q, 0, :field,
+                                    :excerpt_length => 10,
+                                    :num_excerpts => 1)
+    assert_equal(1, highlights.size)
+    assert_equal("...are <b>one</b>...", highlights[0])
+
+    highlights = searcher.highlight(q, 0, :field,
+                                    :excerpt_length => 10,
+                                    :num_excerpts => 2)
+    assert_equal(2, highlights.size)
+    assert_equal("...are <b>one</b>...", highlights[0])
+    assert_equal("...this; <b>one</b>...", highlights[1])
+
+    highlights = searcher.highlight(q, 0, :field,
+                                    :excerpt_length => 10,
+                                    :num_excerpts => 3)
+    assert_equal(3, highlights.size)
+    assert_equal("the words...", highlights[0])
+    assert_equal("...are <b>one</b>...", highlights[1])
+    assert_equal("...this; <b>one</b>...", highlights[2])
+
+    highlights = searcher.highlight(q, 0, :field,
+                                    :excerpt_length => 10,
+                                    :num_excerpts => 4)
+    assert_equal(3, highlights.size)
+    assert_equal("the words we are...", highlights[0])
+    assert_equal("...are <b>one</b>...", highlights[1])
+    assert_equal("...this; <b>one</b>...", highlights[2])
+
+    highlights = searcher.highlight(q, 0, :field,
+                                    :excerpt_length => 10,
+                                    :num_excerpts => 5)
+    assert_equal(2, highlights.size)
+    assert_equal("the words we are searching for are <b>one</b>...", highlights[0])
+    assert_equal("...this; <b>one</b>...", highlights[1])
+
+    highlights = searcher.highlight(q, 0, :field,
+                                    :excerpt_length => 10,
+                                    :num_excerpts => 20)
+    assert_equal(1, highlights.size)
+    assert_equal("the words we are searching for are <b>one</b> and two also " +
+            "sometimes looking for them as a phrase like this; <b>one</b> " +
+            "two lets see how it goes", highlights[0])
+
+    highlights = searcher.highlight(q, 0, :field,
+                                    :excerpt_length => 1000,
+                                    :num_excerpts => 1)
+    assert_equal(1, highlights.size)
+    assert_equal("the words we are searching for are <b>one</b> and two also " +
+            "sometimes looking for them as a phrase like this; <b>one</b> " +
+            "two lets see how it goes", highlights[0])
+
+    q = BooleanQuery.new(false)
+    q << TermQuery.new(:field, "one")
+    q << TermQuery.new(:field, "two")
+
+    highlights = searcher.highlight(q, 0, :field,
+                                    :excerpt_length => 15,
+                                    :num_excerpts => 2)
+    assert_equal(2, highlights.size)
+    assert_equal("...<b>one</b> and <b>two</b>...", highlights[0])
+    assert_equal("...this; <b>one</b> <b>two</b>...", highlights[1])
+
+    q << (PhraseQuery.new(:field) << "one" << "two")
+
+    highlights = searcher.highlight(q, 0, :field,
+                                    :excerpt_length => 15,
+                                    :num_excerpts => 2)
+    assert_equal(2, highlights.size)
+    assert_equal("...<b>one</b> and <b>two</b>...", highlights[0])
+    assert_equal("...this; <b>one two</b>...", highlights[1])
+
+    highlights = searcher.highlight(q, 0, :field,
+                                    :excerpt_length => 15,
+                                    :num_excerpts => 1)
+    assert_equal(1, highlights.size)
+    # should have a higher priority since it the merger of three matches
+    assert_equal("...this; <b>one two</b>...", highlights[0])
+
+    highlights = searcher.highlight(q, 0, :not_a_field,
+                                    :excerpt_length => 15,
+                                    :num_excerpts => 1)
+    assert_nil(highlights)
+
+    q = TermQuery.new(:wrong_field, "one")
+    highlights = searcher.highlight(q, 0, :wrong_field,
+                                    :excerpt_length => 15,
+                                    :num_excerpts => 1)
+    assert_nil(highlights)
+
+    q = BooleanQuery.new(false)
+    q << (PhraseQuery.new(:field) << "the" << "words")
+    q << (PhraseQuery.new(:field) << "for" << "are" << "one" << "and" << "two")
+    q << TermQuery.new(:field, "words")
+    q << TermQuery.new(:field, "one")
+    q << TermQuery.new(:field, "two")
+
+    highlights = searcher.highlight(q, 0, :field,
+                                    :excerpt_length => 10,
+                                    :num_excerpts => 1)
+    assert_equal(1, highlights.size)
+    assert_equal("...<b>for are one and two</b>...", highlights[0])
+
+    highlights = searcher.highlight(q, 0, :field,
+                                    :excerpt_length => 10,
+                                    :num_excerpts => 2)
+    assert_equal(2, highlights.size)
+    assert_equal("<b>the words</b>...", highlights[0])
+    assert_equal("...<b>for are one and two</b>...", highlights[1])
+  end
+end