ferret 0.9.6 → 0.10.0

data/test/unit/search/tc_multi_searcher.rb

@@ -2,12 +2,12 @@ require File.dirname(__FILE__) + "/../../test_helper"
 require File.join(File.dirname(__FILE__), "tc_index_searcher.rb")
 
 # make sure a MultiSearcher searching only one index
-# passes all the IndexSearcher tests
-class SimpleMultiSearcherTest < IndexSearcherTest
+# passes all the Searcher tests
+class SimpleMultiSearcherTest < SearcherTest
   alias :old_setup :setup 
   def setup()
     old_setup
-    @multi = MultiSearcher.new([IndexSearcher.new(@dir)])
+    @searcher = MultiSearcher.new([Searcher.new(@dir)])
   end
 end
 
@@ -16,260 +16,112 @@ end
 # against those of a single indexsearcher searching the same
 # set of documents
 class MultiSearcherTest < Test::Unit::TestCase
-  include Ferret::Document
   include Ferret::Search
   include Ferret::Store
   include Ferret::Analysis
   include Ferret::Index
 
-  def prepare_search_docs(data)
-    docs = []
-    data.each_with_index do |fields, i|
-      doc = Document.new()
-      fields.each_pair do |field, text|
-        doc << Field.new(field, text, Field::Store::YES, Field::Index::TOKENIZED, Field::TermVector::NO, false)
-      end
-      docs << doc
-    end
-    return docs
-  end
-
-  def prepare_documents
-    @documents = prepare_search_docs([
-      {"date" => "20050930", "field" => "word1",
-        "cat" => "cat1/"},
-      {"date" => "20051001", "field" => "word1 word2 the quick brown fox",
-        "cat" => "cat1/sub1"},
-      {"date" => "20051002", "field" => "word1 word3",
-        "cat" => "cat1/sub1/subsub1"},
-      {"date" => "20051003", "field" => "word1 word3",
-        "cat" => "cat1/sub2"},
-      {"date" => "20051004", "field" => "word1 word2",
-        "cat" => "cat1/sub2/subsub2"},
-      {"date" => "20051005", "field" => "word1",
-        "cat" => "cat2/sub1"},
-      {"date" => "20051006", "field" => "word1 word3",
-        "cat" => "cat2/sub1"},
-      {"date" => "20051007", "field" => "word1",
-        "cat" => "cat2/sub1"},
-      {"date" => "20051008", "field" => "word1 word2 word3 the fast brown fox",
-        "cat" => "cat2/sub1"}
-    ])
-    @documents2 = prepare_search_docs([
-      {"date" => "20051009", "field" => "word1",
-        "cat" => "cat3/sub1"},
-      {"date" => "20051010", "field" => "word1",
-        "cat" => "cat3/sub1"},
-      {"date" => "20051011", "field" => "word1 word3 the quick red fox",
-        "cat" => "cat3/sub1"},
-      {"date" => "20051012", "field" => "word1",
-        "cat" => "cat3/sub1"},
-      {"date" => "20051013", "field" => "word1",
-        "cat" => "cat1/sub2"},
-      {"date" => "20051014", "field" => "word1 word3 the quick hairy fox",
-        "cat" => "cat1/sub1"},
-      {"date" => "20051015", "field" => "word1",
-        "cat" => "cat1/sub2/subsub1"},
-      {"date" => "20051016",
-        "field" => "word1 the quick fox is brown and hairy and a little red",
-        "cat" => "cat1/sub1/subsub2"},
-      {"date" => "20051017", "field" => "word1 the brown fox is quick and red",
-        "cat" => "cat1/"}
-    ]) 
-  end
+  include SearcherTests
+
+  DOCUMENTS1 = [
+    {"date" => "20050930", :field => "word1",
+      "cat" => "cat1/"},
+    {"date" => "20051001", :field => "word1 word2 the quick brown fox",
+      "cat" => "cat1/sub1"},
+    {"date" => "20051002", :field => "word1 word3",
+      "cat" => "cat1/sub1/subsub1"},
+    {"date" => "20051003", :field => "word1 word3",
+      "cat" => "cat1/sub2"},
+    {"date" => "20051004", :field => "word1 word2",
+      "cat" => "cat1/sub2/subsub2"},
+    {"date" => "20051005", :field => "word1",
+      "cat" => "cat2/sub1"},
+    {"date" => "20051006", :field => "word1 word3",
+      "cat" => "cat2/sub1"},
+    {"date" => "20051007", :field => "word1",
+      "cat" => "cat2/sub1"},
+    {"date" => "20051008", :field => "word1 word2 word3 the fast brown fox",
+      "cat" => "cat2/sub1"}
+  ]
+
+  DOCUMENTS2 = [
+    {"date" => "20051009", :field => "word1",
+      "cat" => "cat3/sub1"},
+    {"date" => "20051010", :field => "word1",
+      "cat" => "cat3/sub1"},
+    {"date" => "20051011", :field => "word1 word3 the quick red fox",
+      "cat" => "cat3/sub1"},
+    {"date" => "20051012", :field => "word1",
+      "cat" => "cat3/sub1"},
+    {"date" => "20051013", :field => "word1",
+      "cat" => "cat1/sub2"},
+    {"date" => "20051014", :field => "word1 word3 the quick hairy fox",
+      "cat" => "cat1/sub1"},
+    {"date" => "20051015", :field => "word1",
+      "cat" => "cat1/sub2/subsub1"},
+    {"date" => "20051016",
+      :field => "word1 the quick fox is brown and hairy and a little red",
+      "cat" => "cat1/sub1/subsub2"},
+    {"date" => "20051017", :field => "word1 the brown fox is quick and red",
+      "cat" => "cat1/"}
+  ]
 
   def setup()
-    prepare_documents
     # create MultiSearcher from two seperate searchers
     dir1 = RAMDirectory.new()
-    iw1 = IndexWriter.new(dir1, :analyzer => WhiteSpaceAnalyzer.new(), :create => true)
-    @documents.each { |doc| iw1 << doc }
+    iw1 = IndexWriter.new(:dir => dir1,
+                          :analyzer => WhiteSpaceAnalyzer.new(),
+                          :create => true)
+    DOCUMENTS1.each { |doc| iw1 << doc }
     iw1.close()
     
     dir2 = RAMDirectory.new()
-    iw2 = IndexWriter.new(dir2, :analyzer => WhiteSpaceAnalyzer.new(), :create => true)
-    @documents2.each { |doc| iw2 << doc }
+    iw2 = IndexWriter.new(:dir => dir2,
+                          :analyzer => WhiteSpaceAnalyzer.new(),
+                          :create => true)
+    DOCUMENTS2.each { |doc| iw2 << doc }
     iw2.close()
-    @multi = Ferret::Search::MultiSearcher.new([IndexSearcher.new(dir1), IndexSearcher.new(dir2)])
+    @searcher = Ferret::Search::MultiSearcher.new([Searcher.new(dir1),
+                                                   Searcher.new(dir2)])
 
     # create single searcher
     dir = RAMDirectory.new
-    iw = IndexWriter.new(dir, :analyzer => WhiteSpaceAnalyzer.new(), :create => true)
-    @documents.each { |doc| iw << doc }
-    @documents2.each { |doc| iw << doc }
+    iw = IndexWriter.new(:dir => dir,
+                         :analyzer => WhiteSpaceAnalyzer.new(),
+                         :create => true)
+    DOCUMENTS1.each { |doc| iw << doc }
+    DOCUMENTS2.each { |doc| iw << doc }
     iw.close
-    @single = IndexSearcher.new(dir)
+    @single = Searcher.new(dir)
 
-    @query_parser = Ferret::QueryParser.new(['date', 'field', 'cat'], :analyzer => WhiteSpaceAnalyzer.new())
+    #@query_parser = Ferret::QueryParser.new([:date, :field, :cat], :analyzer => WhiteSpaceAnalyzer.new())
   end
 
   def tear_down()
-    @multi.close
+    @searcher.close
     @single.close
   end
 
-  def check_hits(query, debug_field=nil)
-    query = @query_parser.parse(query) if (query.is_a? String)
-    multi_docs = @multi.search(query)
+  def check_hits(query, ignore1, ignore2 = nil, ignore3 = nil)
+    multi_docs = @searcher.search(query)
     single_docs = @single.search(query)
-    IndexTestHelper.explain(query, @single, debug_field) if debug_field
-    IndexTestHelper.explain(query, @multi, debug_field) if debug_field
-    assert_equal(single_docs.score_docs.size, multi_docs.score_docs.size, 'hit count')
+    assert_equal(single_docs.hits.size, multi_docs.hits.size, 'hit count')
     assert_equal(single_docs.total_hits, multi_docs.total_hits, 'hit count')
     
-    multi_docs.score_docs.each_with_index { |sd, id|
-      assert_equal(single_docs.score_docs[id].doc, sd.doc)
-      assert_equal(single_docs.score_docs[id].score, sd.score)
+    multi_docs.hits.each_with_index { |sd, id|
+      assert_equal(single_docs.hits[id].doc, sd.doc)
+      assert_equal(single_docs.hits[id].score, sd.score)
     }
   end
 
   def test_get_doc()
-    assert_equal(18, @multi.max_doc)
-    assert_equal("20050930", @multi.doc(0).values(:date))
-    assert_equal("cat1/sub2/subsub2", @multi.doc(4)[:cat])
-    assert_equal("20051012", @multi.doc(12)[:date])
+    assert_equal(18, @searcher.max_doc)
+    assert_equal("20050930", @searcher.get_document(0)[:date])
+    assert_equal("cat1/sub2/subsub2", @searcher[4][:cat])
+    assert_equal("20051012", @searcher.get_document(12)[:date])
     assert_equal(18, @single.max_doc)
-    assert_equal("20050930", @single.doc(0).values(:date))
-    assert_equal("cat1/sub2/subsub2", @single.doc(4)[:cat])
-    assert_equal("20051012", @single.doc(12)[:date])
-  end
-
-  def test_term_query
-    tq = TermQuery.new(Term.new("field", "word2"));
-    tq.boost = 100
-    check_hits(tq)
-
-    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"));
-    check_hits(tq)
-  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)
-
-    tq3 = TermQuery.new(Term.new("field", "word2"))
-    bq.add_query(tq3, BooleanClause::Occur::SHOULD)
-    check_hits(bq)
-
-    bq = BooleanQuery.new()
-    bq.add_query(tq2, BooleanClause::Occur::MUST)
-    bq.add_query(tq3, BooleanClause::Occur::MUST_NOT)
-    check_hits(bq)
-
-    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)
-  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)
-
-    pq = PhraseQuery.new()
-    pq << t1
-    pq.add(t3, 2)
-    check_hits(pq)
-
-    pq.slop = 1
-    check_hits(pq)
-
-    pq.slop = 4
-    check_hits(pq)
-  end
-
-  def test_range_query()
-    rq = RangeQuery.new("date", "20051006", "20051010", true, true)
-    check_hits(rq)
-
-    rq = RangeQuery.new("date", "20051006", "20051010", false, true)
-    check_hits(rq)
-
-    rq = RangeQuery.new("date", "20051006", "20051010", true, false)
-    check_hits(rq)
-
-    rq = RangeQuery.new("date", "20051006", "20051010", false, false)
-    check_hits(rq)
-
-    rq = RangeQuery.new("date", nil, "20051003", false, true)
-    check_hits(rq)
-
-    rq = RangeQuery.new("date", nil, "20051003", false, false)
-    check_hits(rq)
-
-    rq = RangeQuery.new_less("date", "20051003", true)
-    check_hits(rq)
-
-    rq = RangeQuery.new_less("date", "20051003", false)
-    check_hits(rq)
-
-    rq = RangeQuery.new("date", "20051014", nil, true, false)
-    check_hits(rq)
-
-    rq = RangeQuery.new("date", "20051014", nil, false, false)
-    check_hits(rq)
-
-    rq = RangeQuery.new_more("date", "20051014", true)
-    check_hits(rq)
-
-    rq = RangeQuery.new_more("date", "20051014", false)
-    check_hits(rq)
-  end
-
-  def test_prefix_query()
-    t = Term.new("cat", "cat1")
-    pq = PrefixQuery.new(t)
-    check_hits(pq)
-
-    t.text = "cat1/sub2"
-    pq = PrefixQuery.new(t)
-    check_hits(pq)
-  end
-
-  def test_wildcard_query()
-    t = Term.new("cat", "cat1*")
-    wq = WildcardQuery.new(t)
-    check_hits(wq)
-
-    t.text = "cat1*/su??ub2"
-    wq = WildcardQuery.new(t)
-    check_hits(wq)
-  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)
-
-    mpq.slop = 4
-    check_hits(mpq)
+    assert_equal("20050930", @single.get_document(0)[:date])
+    assert_equal("cat1/sub2/subsub2", @single[4][:cat])
+    assert_equal("20051012", @single.get_document(12)[:date])
   end
 end

data/test/unit/search/tc_search_and_sort.rb

@@ -1,37 +1,32 @@
 require File.dirname(__FILE__) + "/../../test_helper"
 
 class SearchAndSortTest < Test::Unit::TestCase
-  include Ferret::Document
   include Ferret::Search
   include Ferret::Store
   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
-    doc.boost = hash["float"].to_f
-    writer << doc
-  end
-
   def setup()
     @dir = RAMDirectory.new()
-    iw = IndexWriter.new(@dir, :analyzer => WhiteSpaceAnalyzer.new(), :create => true, :min_merge_docs => 3)
-    docs = [                                                             # len mod
-      {"search"=>"findall","string"=>"a","int"=>"6","float"=>"0.01"},    #  4   0
-      {"search"=>"findall","string"=>"c","int"=>"5","float"=>"0.1"},     #  3   3
-      {"search"=>"findall","string"=>"e","int"=>"2","float"=>"0.001"},   #  5   1
-      {"search"=>"findall","string"=>"g","int"=>"1","float"=>"1.0"},     #  3   3
-      {"search"=>"findall","string"=>"i","int"=>"3","float"=>"0.0001"},  #  6   2
-      {"search"=>"findall","string"=>"j","int"=>"4","float"=>"10.0"},    #  4   0
-      {"search"=>"findall","string"=>"h","int"=>"5","float"=>"0.00001"}, #  7   3
-      {"search"=>"findall","string"=>"f","int"=>"2","float"=>"100.0"},   #  5   1
-      {"search"=>"findall","string"=>"d","int"=>"3","float"=>"1000.0"},  #  6   2
-      {"search"=>"findall","string"=>"b","int"=>"4","float"=>"0.000001"} #  8   0
-    ]
-    docs.each {|doc| add_doc(doc, iw)}
+    iw = IndexWriter.new(:dir => @dir,
+                         :analyzer => WhiteSpaceAnalyzer.new(),
+                         :create => true, :min_merge_docs => 3)
+    [                                                                      # len mod
+      {:x => "findall", :string => "a", :int => "6", :float => "0.01"},    #  4   0
+      {:x => "findall", :string => "c", :int => "5", :float => "0.1"},     #  3   3
+      {:x => "findall", :string => "e", :int => "2", :float => "0.001"},   #  5   1
+      {:x => "findall", :string => "g", :int => "1", :float => "1.0"},     #  3   3
+      {:x => "findall", :string => "i", :int => "3", :float => "0.0001"},  #  6   2
+      {:x => "findall", :string => "j", :int => "4", :float => "10.0"},    #  4   0
+      {:x => "findall", :string => "h", :int => "5", :float => "0.00001"}, #  7   3
+      {:x => "findall", :string => "f", :int => "2", :float => "100.0"},   #  5   1
+      {:x => "findall", :string => "d", :int => "3", :float => "1000.0"},  #  6   2
+      {:x => "findall", :string => "b", :int => "4", :float => "0.000001"} #  8   0
+    ].each do |doc|
+      doc.extend(Ferret::BoostMixin)
+      doc.boost = doc[:float].to_f
+      iw << doc
+    end
     iw.close
   end
 
@@ -42,57 +37,57 @@ class SearchAndSortTest < Test::Unit::TestCase
   def do_test_top_docs(is, query, expected, sort = nil)
     top_docs = is.search(query, {:sort => sort})
     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
 
     # test sorting works for smaller ranged query
-    first_doc = 3
-    num_docs = 3
+    offset = 3
+    limit = 3
     top_docs = is.search(query, {:sort => sort,
-                                 :first_doc => first_doc,
-                                 :num_docs => num_docs})
-    num_docs.times do |i|
-      assert_equal(expected[first_doc + i], top_docs.score_docs[i].doc)
+                                 :offset => offset,
+                                 :limit => limit})
+    limit.times do |i|
+      assert_equal(expected[offset + i], top_docs.hits[i].doc)
     end
   end
 
   def test_sort_field_to_s()
-    assert_equal("<SCORE>", SortField::FIELD_SCORE.to_s);
+    assert_equal("<SCORE>", SortField::SCORE.to_s);
     sf = SortField.new("MyScore",
-                       {:sort_type => SortField::SortType::SCORE,
+                       {:type => :score,
                         :reverse => true})
     assert_equal("MyScore:<SCORE>!", sf.to_s)
-    assert_equal("<DOC>", SortField::FIELD_DOC.to_s);
+    assert_equal("<DOC>", SortField::DOC_ID.to_s);
     sf = SortField.new("MyDoc",
-                       {:sort_type => SortField::SortType::DOC,
+                       {:type => :doc_id,
                         :reverse => true})
     assert_equal("MyDoc:<DOC>!", sf.to_s)
-    sf = SortField.new("date",
-                       {:sort_type => SortField::SortType::INTEGER})
+    sf = SortField.new(:date,
+                       {:type => :integer})
     assert_equal("date:<integer>", sf.to_s)
-    sf = SortField.new("date",
-                       {:sort_type => SortField::SortType::INTEGER,
+    sf = SortField.new(:date,
+                       {:type => :integer,
                         :reverse => true})
     assert_equal("date:<integer>!", sf.to_s)
-    sf = SortField.new("price",
-                       {:sort_type => SortField::SortType::FLOAT})
+    sf = SortField.new(:price,
+                       {:type => :float})
     assert_equal("price:<float>", sf.to_s)
-    sf = SortField.new("price",
-                       {:sort_type => SortField::SortType::FLOAT,
+    sf = SortField.new(:price,
+                       {:type => :float,
                         :reverse => true})
     assert_equal("price:<float>!", sf.to_s)
-    sf = SortField.new("content",
-                       {:sort_type => SortField::SortType::STRING})
+    sf = SortField.new(:content,
+                       {:type => :string})
     assert_equal("content:<string>", sf.to_s)
-    sf = SortField.new("content",
-                       {:sort_type => SortField::SortType::STRING,
+    sf = SortField.new(:content,
+                       {:type => :string,
                         :reverse => true})
     assert_equal("content:<string>!", sf.to_s)
-    sf = SortField.new("auto_field",
-                       {:sort_type => SortField::SortType::AUTO})
+    sf = SortField.new(:auto_field,
+                       {:type => :auto})
     assert_equal("auto_field:<auto>", sf.to_s)
-    sf = SortField.new("auto_field",
-                       {:sort_type => SortField::SortType::AUTO,
+    sf = SortField.new(:auto_field,
+                       {:type => :auto,
                         :reverse => true})
     assert_equal("auto_field:<auto>!", sf.to_s)
   end
@@ -100,53 +95,70 @@ class SearchAndSortTest < Test::Unit::TestCase
   def test_sort_to_s()
     sort = Sort.new
     assert_equal("Sort[<SCORE>, <DOC>]", sort.to_s)
-    sf = SortField.new("auto_field",
-                       {:sort_type => SortField::SortType::AUTO,
+    sf = SortField.new(:auto_field,
+                       {:type => :auto,
                         :reverse => true})
-    sort = Sort.new([sf, SortField::FIELD_SCORE, SortField::FIELD_DOC])
+    sort = Sort.new([sf, SortField::SCORE, SortField::DOC_ID])
     assert_equal("Sort[auto_field:<auto>!, <SCORE>, <DOC>]", sort.to_s)
-    sort = Sort.new(["one", "two", SortField::FIELD_DOC])
+    sort = Sort.new([:one, :two, SortField::DOC_ID])
     assert_equal("Sort[one:<auto>, two:<auto>, <DOC>]", sort.to_s)
-    sort = Sort.new(["one", "two"])
+    sort = Sort.new([:one, :two])
     assert_equal("Sort[one:<auto>, two:<auto>, <DOC>]", sort.to_s)
   end
 
 
   def test_sorts()
-    is = IndexSearcher.new(@dir)
-    q = TermQuery.new(Term.new("search", "findall"))
+    is = Searcher.new(@dir)
+    q = TermQuery.new(:x, "findall")
     do_test_top_docs(is, q, [8,7,5,3,1,0,2,4,6,9])
     do_test_top_docs(is, q, [8,7,5,3,1,0,2,4,6,9], Sort::RELEVANCE)
-    do_test_top_docs(is, q, [8,7,5,3,1,0,2,4,6,9], [SortField::FIELD_SCORE])
+    do_test_top_docs(is, q, [8,7,5,3,1,0,2,4,6,9], [SortField::SCORE])
     do_test_top_docs(is, q, [0,1,2,3,4,5,6,7,8,9], Sort::INDEX_ORDER)
-    do_test_top_docs(is, q, [0,1,2,3,4,5,6,7,8,9], [SortField::FIELD_DOC])
+    do_test_top_docs(is, q, [0,1,2,3,4,5,6,7,8,9], [SortField::DOC_ID])
 
     ## int
-    sf_int = SortField.new("int", {:sort_type => SortField::SortType::INTEGER, :reverse => true})
+    sf_int = SortField.new(:int, {:type => :integer, :reverse => true})
     do_test_top_docs(is, q, [0,1,6,5,9,4,8,2,7,3], [sf_int])
-    do_test_top_docs(is, q, [0,1,6,5,9,8,4,7,2,3], [sf_int, SortField::FIELD_SCORE])
-    sf_int = SortField.new("int", {:sort_type => SortField::SortType::INTEGER})
+    do_test_top_docs(is, q, [0,1,6,5,9,4,8,2,7,3], "int DESC")
+    do_test_top_docs(is, q, [0,1,6,5,9,8,4,7,2,3], [sf_int, SortField::SCORE])
+    do_test_top_docs(is, q, [0,1,6,5,9,8,4,7,2,3], "int DESC, SCORE")
+    sf_int = SortField.new(:int, {:type => :integer})
     do_test_top_docs(is, q, [3,2,7,4,8,5,9,1,6,0], [sf_int])
+    do_test_top_docs(is, q, [3,2,7,4,8,5,9,1,6,0], "int")
+
+    ## byte
+    do_test_top_docs(is, q, [3,2,7,4,8,5,9,1,6,0],
+                     [SortField.new(:int, :type => :byte)])
+    do_test_top_docs(is, q, [0,1,6,5,9,4,8,2,7,3],
+                     [SortField.new(:int, :type => :byte, :reverse => true)])
+    
 
     ## float
-    sf_float = SortField.new("float", {:sort_type => SortField::SortType::FLOAT, :reverse => true})
-    do_test_top_docs(is, q, [8,7,5,3,1,0,2,4,6,9], Sort.new([sf_float, SortField::FIELD_SCORE]))
-    sf_float = SortField.new("float", {:sort_type => SortField::SortType::FLOAT})
-    do_test_top_docs(is, q, [9,6,4,2,0,1,3,5,7,8], Sort.new([sf_float, SortField::FIELD_SCORE]))
+    sf_float = SortField.new(:float, {:type => :float, :reverse => true})
+    do_test_top_docs(is, q, [8,7,5,3,1,0,2,4,6,9],
+                     Sort.new([sf_float, SortField::SCORE]))
+    do_test_top_docs(is, q, [8,7,5,3,1,0,2,4,6,9], "float DESC, SCORE")
+    sf_float = SortField.new(:float, {:type => :float})
+    do_test_top_docs(is, q, [9,6,4,2,0,1,3,5,7,8],
+                     Sort.new([sf_float, SortField::SCORE]))
+    do_test_top_docs(is, q, [9,6,4,2,0,1,3,5,7,8], "float, SCORE")
 
     ## str
-    sf_str = SortField.new("string", {:sort_type => SortField::SortType::STRING})
-    do_test_top_docs(is, q, [0,9,1,8,2,7,3,6,4,5], [sf_str, SortField::FIELD_SCORE])
+    sf_str = SortField.new(:string, {:type => :string})
+    do_test_top_docs(is, q, [0,9,1,8,2,7,3,6,4,5], [sf_str, SortField::SCORE])
+    do_test_top_docs(is, q, [0,9,1,8,2,7,3,6,4,5], "string")
 
     ## auto
-    do_test_top_docs(is, q, [0,9,1,8,2,7,3,6,4,5], Sort.new("string"))
-    do_test_top_docs(is, q, [3,2,7,4,8,5,9,1,6,0], Sort.new(["int"]))
-    do_test_top_docs(is, q, [9,6,4,2,0,1,3,5,7,8], Sort.new("float"))
-    do_test_top_docs(is, q, [9,6,4,2,0,1,3,5,7,8], "float")
-    do_test_top_docs(is, q, [8,7,5,3,1,0,2,4,6,9], Sort.new("float", true))
-    do_test_top_docs(is, q, [0,6,1,5,9,4,8,7,2,3], Sort.new(["int", "string"], true))
-    do_test_top_docs(is, q, [3,2,7,8,4,9,5,1,6,0], Sort.new(["int", "string"]))
-    do_test_top_docs(is, q, [3,2,7,8,4,9,5,1,6,0], [:int, "string"])
+    do_test_top_docs(is, q, [0,9,1,8,2,7,3,6,4,5], Sort.new(:string))
+    do_test_top_docs(is, q, [3,2,7,4,8,5,9,1,6,0], Sort.new([:int]))
+    do_test_top_docs(is, q, [9,6,4,2,0,1,3,5,7,8], Sort.new(:float))
+    do_test_top_docs(is, q, [9,6,4,2,0,1,3,5,7,8], :float)
+    do_test_top_docs(is, q, [8,7,5,3,1,0,2,4,6,9], Sort.new(:float, true))
+    do_test_top_docs(is, q, [0,6,1,5,9,4,8,7,2,3], Sort.new([:int, :string], true))
+    do_test_top_docs(is, q, [0,6,1,5,9,4,8,7,2,3], "int DESC, string DESC")
+    do_test_top_docs(is, q, [3,2,7,8,4,9,5,1,6,0], Sort.new([:int, :string]))
+    do_test_top_docs(is, q, [3,2,7,8,4,9,5,1,6,0], [:int, :string])
+    do_test_top_docs(is, q, [3,2,7,8,4,9,5,1,6,0], "int, string")
   end
 
   #LENGTH = SortField::SortType.new("length", lambda{|str| str.length})
@@ -154,12 +166,12 @@ class SearchAndSortTest < Test::Unit::TestCase
   #                                        lambda{|i, j| (i%4) <=> (j%4)})
   #def test_special_sorts
   #  is = IndexSearcher.new(@dir)
-  #  q = TermQuery.new(Term.new("search", "findall"))
-  #  sf = SortField.new("float", {:sort_type => LENGTH, :reverse => true})
+  #  q = TermQuery.new(Term.new(:x, "findall"))
+  #  sf = SortField.new(:float, {:type => LENGTH, :reverse => true})
   #  do_test_top_docs(is, q, [9,6,4,8,2,7,0,5,1,3], [sf])
-  #  sf = SortField.new("float", {:sort_type => LENGTH_MODULO, :reverse => true})
+  #  sf = SortField.new(:float, {:type => LENGTH_MODULO, :reverse => true})
   #  do_test_top_docs(is, q, [1,3,6,4,8,2,7,0,5,9], [sf])
-  #  sf = SortField.new("float", {:sort_type => LENGTH,
+  #  sf = SortField.new(:float, {:type => LENGTH,
   #                               :reverse => true,
   #                               :comparator => lambda{|i,j| (j%4) <=> (i%4)}})
   #  do_test_top_docs(is, q, [0,5,9,2,7,4,8,1,3,6], [sf])