ferret 0.3.2 → 0.9.0

data/test/unit/search/{tc_filter.rb → c_filter.rb}

@@ -51,7 +51,7 @@ class FilterTest < Test::Unit::TestCase
 
   def test_range_filter
     is = IndexSearcher.new(@dir)
-    q = MatchAllDocsQuery.new()
+    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)
@@ -79,7 +79,7 @@ class FilterTest < Test::Unit::TestCase
 
   def test_query_filter()
     is = IndexSearcher.new(@dir)
-    q = MatchAllDocsQuery.new()
+    q = MatchAllQuery.new()
     qf = QueryFilter.new(TermQuery.new(Term.new("switch", "on")))
     do_test_top_docs(is, q, [0,2,4,6,8], qf)
     # test again to test caching doesn't break it
@@ -88,26 +88,26 @@ class FilterTest < Test::Unit::TestCase
     do_test_top_docs(is, q, [1,3,5,7,9], qf)
   end
 
-  def test_caching_wrapper_filter
-    is = IndexSearcher.new(@dir)
-    q = MatchAllDocsQuery.new()
-    rf = RangeFilter.new("int", "2", "6", true, true)
-    cf = CachingWrapperFilter.new(rf)
-    #puts "about to test cache"
-    do_test_top_docs(is, q, [2,3,4,5,6], cf)
-    do_test_top_docs(is, q, [2,3,4,5,6], cf)
-    #puts "finished_testing_cache"
-  end
-
-  def test_filtered_query
-    is = IndexSearcher.new(@dir)
-    q = MatchAllDocsQuery.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
+  #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
+  #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_index_searcher.rb → c_index_searcher.rb}

@@ -11,7 +11,7 @@ class IndexSearcherTest < Test::Unit::TestCase
     @dir = RAMDirectory.new()
     iw = IndexWriter.new(@dir, :analyzer => WhiteSpaceAnalyzer.new(), :create => true)
     @documents = IndexTestHelper.prepare_search_docs()
-    @documents.each { |doc| iw << doc; }
+    @documents.each { |doc| iw << doc }
     iw.close()
     @is = IndexSearcher.new(@dir)
   end
@@ -62,20 +62,20 @@ class IndexSearcherTest < Test::Unit::TestCase
   end
 
   def test_term_query
-    tq = TermQuery.new(Term.new("field", "word2"));
+    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"));
+    tq = TermQuery.new(Term.new("field", "2342"))
     check_hits(tq, [])
 
-    tq = TermQuery.new(Term.new("field", ""));
+    tq = TermQuery.new(Term.new("field", ""))
     check_hits(tq, [])
 
-    tq = TermQuery.new(Term.new("field", "word1"));
+    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)
@@ -85,12 +85,12 @@ class IndexSearcherTest < Test::Unit::TestCase
 
 
   def test_first_doc
-    tq = TermQuery.new(Term.new("field", "word1"));
+    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 |score_doc|
-      expected << score_doc.doc
+    top_docs.score_docs.each do |sd|
+      expected << sd.doc
     end
 
     assert_raise(ArgumentError) { @is.search(tq, {:first_doc => -1}) }
@@ -151,23 +151,6 @@ class IndexSearcherTest < Test::Unit::TestCase
     check_hits(pq, [1,11,14,16,17])
   end
 
-  def test_multi_phrase_query()
-    pq = MultiPhraseQuery.new()
-    t1 = Term.new("field", "quick")
-    t2 = Term.new("field", "brown")
-    t3 = Term.new("field", "fox")
-    pq << t1
-    pq << t2
-    pq << t3
-    check_hits(pq, [1])
-
-    t1b = Term.new("field", "fast")
-    pq.add(t1b, 0)
-    check_hits(pq, [1, 8])
-  end
-
-
-
   def test_range_query()
     rq = RangeQuery.new("date", "20051006", "20051010", true, true)
     check_hits(rq, [6,7,8,9,10])
@@ -226,7 +209,7 @@ class IndexSearcherTest < Test::Unit::TestCase
     check_hits(wq, [4, 16])
   end
 
-  def test_prefix_query()
+  def test_multi_phrase_query()
     t11 = Term.new("field", "quick")
     t12 = Term.new("field", "fast")
     t21 = Term.new("field", "brown")

data/test/unit/search/{tc_search_and_sort.rb → c_search_and_sort.rb}

@@ -81,19 +81,19 @@ class SearchAndSortTest < Test::Unit::TestCase
     do_test_top_docs(is, q, [3,2,7,8,4,9,5,1,6,0], Sort.new(["int", "string"]))
   end
 
-  LENGTH = SortField::SortType.new("length", lambda{|str| str.length})
-  LENGTH_MODULO = SortField::SortType.new("length_mod", lambda{|str| str.length},
-                                          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})
-    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})
-    do_test_top_docs(is, q, [1,3,6,4,8,2,7,0,5,9], [sf])
-    sf = SortField.new("float", {:sort_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])
-  end
+  #LENGTH = SortField::SortType.new("length", lambda{|str| str.length})
+  #LENGTH_MODULO = SortField::SortType.new("length_mod", lambda{|str| str.length},
+  #                                        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})
+  #  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})
+  #  do_test_top_docs(is, q, [1,3,6,4,8,2,7,0,5,9], [sf])
+  #  sf = SortField.new("float", {:sort_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])
+  #end
 end

data/test/unit/search/{tc_sort.rb → c_sort.rb}

@@ -22,13 +22,14 @@ class SortTest < Test::Unit::TestCase
     assert_equal(SortField::FIELD_DOC, s.fields[1])
 
     s = Sort.new(["field1", "field2", "field3"])
-    assert_equal(3, s.fields.size)
+    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])
   end
 
   def test_multi_fields()

data/test/unit/search/c_sort_field.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+class SortFieldTest < Test::Unit::TestCase
+  include Ferret::Search
+
+  def test_field_score()
+    fs = SortField::FIELD_SCORE
+    assert_equal(SortField::SortType::SCORE, fs.sort_type)
+    assert_nil(fs.name)
+    assert(!fs.reverse?, "FIELD_SCORE 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)
+    assert_nil(fs.name)
+    assert(!fs.reverse?, "FIELD_DOC should not be reverse")
+    assert_nil(fs.comparator)
+  end
+
+  def test_error_raised()
+    assert_raise(ArgumentError) {
+      fs = SortField.new(nil, {:sort_type => SortField::SortType::INTEGER})
+    }
+  end
+end

data/test/unit/search/tc_sort_field.rb

@@ -3,25 +3,12 @@ require File.dirname(__FILE__) + "/../../test_helper"
 class SortFieldTest < Test::Unit::TestCase
   include Ferret::Search
 
-  def test_field_score()
-    fs = SortField::FIELD_SCORE
-    assert_equal(SortField::SortType::SCORE, fs.sort_type)
-    assert_nil(fs.name)
-    assert(!fs.reverse?, "FIELD_SCORE 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)
-    assert_nil(fs.name)
-    assert(!fs.reverse?, "FIELD_DOC should not be reverse")
-    assert_nil(fs.comparator)
-  end
-
-  def test_error_raised()
-    assert_raise(ArgumentError) {
-      fs = SortField.new(nil, {:sort_type => SortField::SortType::INTEGER})
-    }
+  def test_params()
+    assert_equal("score",  SortField::SortType::SCORE.to_s)
+    assert_equal("doc",    SortField::SortType::DOC.to_s)
+    assert_equal("auto",   SortField::SortType::AUTO.to_s)
+    assert_equal("string", SortField::SortType::STRING.to_s)
+    assert_equal("int",    SortField::SortType::INTEGER.to_s)
+    assert_equal("float",  SortField::SortType::FLOAT.to_s)
   end
 end

data/test/unit/store/c_fs_store.rb

@@ -0,0 +1,76 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+require File.dirname(__FILE__) + "/m_store"
+require File.dirname(__FILE__) + "/m_store_lock"
+
+class FSStoreTest < Test::Unit::TestCase
+  include Ferret::Store
+  include StoreTest
+  include StoreLockTest
+  def setup
+    @dpath = File.join(File.dirname(__FILE__),
+                       '../../temp/fsdir')
+    @dir = FSDirectory.new(@dpath, true)
+    @dir1 = FSDirectory.new(@dpath, true)
+    @dir2 = FSDirectory.new(@dpath, true)
+  end
+
+  def teardown
+    @dir.refresh()
+    @dir.close()
+  end
+
+  def test_fslock
+    lock_name = "lfile"
+    lock_file_path = make_lock_file_path(lock_name)
+    assert(! File.exists?(lock_file_path), "There should be no lock file")
+    lock = @dir.make_lock(lock_name)
+    assert(! File.exists?(lock_file_path), "There should still be no lock file")
+    assert(! lock.locked?,                 "lock shouldn't be locked yet")
+
+    lock.obtain
+
+    assert(lock.locked?,                   "lock should now be locked")
+
+    assert(File.exists?(lock_file_path),   "A lock file should have been created")
+
+    assert(! @dir.exists?(lock_file_path),
+           "The lock should be hidden by the FSDirectories directory scan")
+
+    lock.release
+
+    assert(! lock.locked?,                 "lock should be freed again")
+    assert(! File.exists?(lock_file_path), "The lock file should have been deleted")
+  end
+
+#  def make_and_loose_lock
+#    lock = @dir.make_lock("finalizer_lock")
+#    lock.obtain
+#    lock = nil
+#  end
+#
+#  def test_fslock_finalizer
+#    lock_name = "finalizer_lock"
+#    lock_file_path = make_lock_file_path(lock_name)
+#    assert(! File.exists?(lock_file_path), "There should be no lock file")
+#
+#    make_and_loose_lock
+#
+#    #assert(File.exists?(lock_file_path), "There should now be a lock file")
+#
+#    lock = @dir.make_lock(lock_name)
+#    assert(lock.locked?, "lock should now be locked")
+#
+#    GC.start
+#
+#    assert(! lock.locked?, "lock should be freed again")
+#    assert(! File.exists?(lock_file_path), "The lock file should have been deleted")
+#  end
+#
+  def make_lock_file_path(name)
+    lock_file_path = File.join(@dpath, "ferret-#{name}.lck")
+    if File.exists?(lock_file_path) then
+      File.delete(lock_file_path)
+    end
+    return lock_file_path
+  end
+end

data/test/unit/store/c_ram_store.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+require File.dirname(__FILE__) + "/m_store"
+require File.dirname(__FILE__) + "/m_store_lock"
+
+class RAMStoreTest < Test::Unit::TestCase
+  include StoreTest
+  include StoreLockTest
+  def setup
+    @dir = Ferret::Store::RAMDirectory.new
+  end
+
+  def teardown
+    @dir.close()
+  end
+
+  def test_ramlock
+    name = "lfile"
+    lfile = Ferret::Store::Directory::LOCK_PREFIX + name + ".lck"
+    assert(! @dir.exists?(lfile),
+           "There should be no lock file")
+    lock = @dir.make_lock(name)
+    assert(! @dir.exists?(lfile),
+           "There should still be no lock file")
+    assert(! @dir.exists?(lfile),
+           "The lock should be hidden by the FSDirectories directory scan")
+    assert(! lock.locked?, "lock shouldn't be locked yet")
+    lock.obtain
+    assert(lock.locked?, "lock should now be locked")
+    assert(@dir.exists?(lfile), "A lock file should have been created")
+    lock.release
+    assert(! lock.locked?, "lock should be freed again")
+    assert(! @dir.exists?(lfile),
+           "The lock file should have been deleted")
+  end
+end

data/test/unit/store/m_store.rb

@@ -0,0 +1,34 @@
+module StoreTest
+  # declare dir so inheritors can access it.
+  attr_accessor :dir
+
+  # test the basic file manipulation methods;
+  # - exists?
+  # - touch
+  # - delete
+  # - file_count
+  def test_basic_file_ops
+    assert_equal(0, @dir.file_count(), "directory should be empty")
+    assert(! @dir.exists?('filename'), "File should not exist")
+    @dir.touch('tmpfile1')
+    assert_equal(1, @dir.file_count(), "directory should have one file")
+    @dir.touch('tmpfile2')
+    assert_equal(2, @dir.file_count(), "directory should have two files")
+    assert(@dir.exists?('tmpfile1'), "'tmpfile1' should exist")
+    @dir.delete('tmpfile1')
+    assert(! @dir.exists?('tmpfile1'), "'tmpfile1' should no longer exist")
+    assert_equal(1, @dir.file_count(), "directory should have one file")
+  end
+  
+  def test_rename
+    @dir.touch("from")
+    assert(@dir.exists?('from'), "File should exist")
+    assert(! @dir.exists?('to'), "File should not exist")
+    cnt_before = @dir.file_count()
+    @dir.rename('from', 'to')
+    cnt_after = @dir.file_count()
+    assert_equal(cnt_before, cnt_after, "the number of files shouldn't have changed")
+    assert(@dir.exists?('to'), "File should now exist")
+    assert(! @dir.exists?('from'), "File should no longer exist")
+  end
+end

data/test/unit/store/m_store_lock.rb

@@ -0,0 +1,68 @@
+module StoreLockTest
+  class Switch
+    @@counter = 0
+    def Switch.counter() return @@counter end
+    def Switch.counter=(counter) @@counter = counter end
+  end
+
+  def test_locking()
+    lock_time_out = 0.001 # we want this test to run quickly
+    lock1 = @dir.make_lock("l.lck")
+    lock2 = @dir.make_lock("l.lck")
+
+    assert(!lock2.locked?)
+    assert(lock1.obtain(lock_time_out))
+    assert(lock2.locked?)
+
+    assert(! obtain_lock_true_false(lock2))
+
+    exception_thrown = false
+    begin
+      lock2.while_locked(lock_time_out) do
+        assert(false, "lock should not have been obtained")
+      end
+    rescue
+      exception_thrown = true
+    ensure
+      assert(exception_thrown)
+    end
+
+    lock1.release()
+    assert(lock2.obtain(lock_time_out))
+    lock2.release()
+
+    t = Thread.new() do
+      lock1.while_locked(lock_time_out) do
+        Switch.counter = 1
+        # make sure lock2 obtain test was run
+        while Switch.counter < 2
+        end
+        Switch.counter = 3
+      end
+    end
+    t.run()
+
+    #make sure thread has started and lock been obtained
+    while Switch.counter < 1
+    end
+    
+    assert(! obtain_lock_true_false(lock2))
+
+    Switch.counter = 2
+    while Switch.counter < 3
+    end
+    
+    assert(lock2.obtain(lock_time_out))
+    lock2.release()
+  end
+
+  def obtain_lock_true_false(lock)
+    lock_time_out = 0.001 # we want this test to run quickly
+    begin
+      lock.obtain(lock_time_out)
+      return true
+    rescue
+    end
+    return false
+  end
+end