ferret 0.9.0 → 0.9.1

data/test/unit/document/c_field.rb

@@ -1,98 +0,0 @@
-require File.dirname(__FILE__) + "/../../test_helper"
-
-
-class FieldTest < Test::Unit::TestCase
-  include Ferret::Document
-  include Ferret::Utils
-
-  def test_store()
-    assert_not_nil(Field::Store::COMPRESS)
-    assert_not_nil(Field::Store::YES)
-    assert_not_nil(Field::Store::NO)
-  end
-
-  def test_index()
-    assert_not_nil(Field::Index::TOKENIZED)
-    assert_not_nil(Field::Index::UNTOKENIZED)
-    assert_not_nil(Field::Index::NO)
-    assert_not_nil(Field::Index::NO_NORMS)
-  end
-
-  def test_term_vector()
-    assert_not_nil(Field::TermVector::YES)
-    assert_not_nil(Field::TermVector::NO)
-    assert_not_nil(Field::TermVector::WITH_POSITIONS)
-    assert_not_nil(Field::TermVector::WITH_OFFSETS)
-    assert_not_nil(Field::TermVector::WITH_POSITIONS_OFFSETS)
-  end
-
-  def test_standard_field()
-    f = Field.new("name", "value", Field::Store::COMPRESS, Field::Index::TOKENIZED)
-    assert_equal("name", f.name)
-    assert_equal("value", f.data)
-    assert_equal(true, f.stored?)
-    assert_equal(true, f.compressed?)
-    assert_equal(true, f.indexed?)
-    assert_equal(true, f.tokenized?)
-    assert_equal(false, f.store_term_vector?)
-    assert_equal(false, f.store_offsets?)
-    assert_equal(false, f.store_positions?)
-    assert_equal(false, f.omit_norms?)
-    assert_equal(false, f.binary?)
-    assert_equal("stored/compressed,indexed,tokenized,<name:value>", f.to_s)
-    f.data = "183"
-    f.boost = 0.001
-    assert_equal("183", f.data)
-    assert(0.001 =~ f.boost)
-  end
-
-  def test_set_store()
-    f = Field.new("name", "", Field::Store::COMPRESS, Field::Index::TOKENIZED)
-    f.store = Field::Store::NO
-    assert_equal(false, f.stored?)
-    assert_equal(false, f.compressed?)
-    assert_equal("indexed,tokenized,<name:>", f.to_s)
-  end
-
-  def test_set_index()
-    f = Field.new("name", "value", Field::Store::COMPRESS, Field::Index::TOKENIZED)
-    f.index = Field::Index::NO
-    assert_equal(false, f.indexed?)
-    assert_equal(false, f.tokenized?)
-    assert_equal(false, f.omit_norms?)
-    assert_equal("stored/compressed,<name:value>", f.to_s)
-    f.index = Field::Index::NO_NORMS
-    assert_equal(true, f.indexed?)
-    assert_equal(false, f.tokenized?)
-    assert_equal(true, f.omit_norms?)
-    assert_equal("stored/compressed,indexed,omit_norms,<name:value>", f.to_s)
-  end
-
-  def test_set_term_vector()
-    f = Field.new("name", "value", Field::Store::COMPRESS, Field::Index::TOKENIZED)
-    f.term_vector = Field::TermVector::WITH_POSITIONS_OFFSETS
-    assert_equal(true, f.store_term_vector?)
-    assert_equal(true, f.store_offsets?)
-    assert_equal(true, f.store_positions?)
-    assert_equal("stored/compressed,indexed,tokenized,store_term_vector,store_offsets,store_positions,<name:value>", f.to_s)
-  end
-
-  def test_new_binary_field()
-    tmp = []
-    256.times {|i| tmp[i] = i}
-    bin = tmp.pack("c*")
-    f = Field.new_binary_field("name", bin, Field::Store::YES)
-    assert_equal("name", f.name)
-    assert_equal(bin, f.data)
-    assert_equal(true, f.stored?)
-    assert_equal(false, f.compressed?)
-    assert_equal(false, f.indexed?)
-    assert_equal(false, f.tokenized?)
-    assert_equal(false, f.store_term_vector?)
-    assert_equal(false, f.store_offsets?)
-    assert_equal(false, f.store_positions?)
-    assert_equal(false, f.omit_norms?)
-    assert_equal(true, f.binary?)
-    assert_equal("stored/uncompressed,binary,<name:=bin_data=>", f.to_s)
-  end
-end

data/test/unit/search/c_sort_field.rb

@@ -1,27 +0,0 @@
-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/store/c_fs_store.rb

@@ -1,76 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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