ferret 0.9.0 → 0.9.1

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

@@ -88,17 +88,17 @@ class FilterTest < Test::Unit::TestCase
     do_test_top_docs(is, q, [1,3,5,7,9], qf)
   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
   #def test_filtered_query
   #  is = IndexSearcher.new(@dir)
   #  q = MatchAllQuery.new()

data/test/unit/search/tc_sort_field.rb

@@ -3,12 +3,25 @@ require File.dirname(__FILE__) + "/../../test_helper"
 class SortFieldTest < Test::Unit::TestCase
   include Ferret::Search
 
-  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)
+  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/rtc_fs_store.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+require File.dirname(__FILE__) + "/rtm_store"
+require File.dirname(__FILE__) + "/rtm_store_lock"
+
+module Ferret::Store
+
+  class FSDirectory
+    def FSDirectory.directory_cache
+      @@Directories
+    end
+
+    def ref_count
+      @ref_count
+    end
+
+    def get_lock_prefix
+      lock_prefix
+    end
+  end
+end
+
+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)
+  end
+
+  def teardown
+    @dir.refresh()
+    @dir.close()
+  end
+
+  def test_cache
+    dir_path = File.join(File.dirname(__FILE__),
+                         '/../../temp/cachetest')
+    assert(! FSDirectory.directory_cache[dir_path],
+           "this directory should not be cached yet") 
+    @dir1 = FSDirectory.new(dir_path, true)
+    assert(FSDirectory.directory_cache[dir_path],
+           "this directory should now be cached") 
+    assert_equal(@dir1.ref_count, 1,
+                 "There is one reference so the refcount should now be 1")
+    @dir2 = FSDirectory.new(dir_path, true)
+    assert(@dir1 === @dir2,
+           "The directory should be cached so the same directory object should have been returned")
+    assert_equal(@dir1.ref_count, 2,
+                 "There are two references so the refcount should now be 2")
+    @dir1.close
+    assert(FSDirectory.directory_cache[dir_path],
+           "this directory shouldn't have been removed yet") 
+    assert_equal(@dir2.ref_count, 1,
+                 "There is one reference so the refcount should now be 1")
+    @dir2.close
+    assert(! FSDirectory.directory_cache[dir_path],
+           "this directory should have been removed from the cache") 
+  end
+
+end

data/test/unit/store/rtc_ram_store.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+require File.dirname(__FILE__) + "/rtm_store"
+require File.dirname(__FILE__) + "/rtm_store_lock"
+
+class RAMStoreTest < Test::Unit::TestCase
+  include StoreTest
+  include StoreLockTest
+  def setup
+    @dir = Ferret::Store::RAMDirectory.new
+  end
+
+  def teardown
+    @dir.close()
+  end
+end

data/test/unit/store/rtm_store.rb

@@ -0,0 +1,150 @@
+module StoreTest
+  # declare dir so inheritors can access it.
+  @dir = nil
+
+  def test_modified
+    # difficult to test this one but as file mtime is only stored to the nearest second.
+    # we can assume this test will happen in less than a few seconds. (I hope)
+    time = Time.new.to_i
+    @dir.touch('mtime.test')
+    time_before = @dir.modified('mtime.test').to_i
+    assert(time_before - time <= 3,
+           "test that mtime is approximately equal to the system time when the file was touched")
+  end
+
+  def test_rw_bytes
+    bytes = [0x34, 0x87, 0xF9, 0xEA, 0x00, 0xFF]
+    rw_test(bytes, "byte", 6)
+  end
+
+  def test_rw_ints
+    ints = [-2147483648, 2147483647, -1, 0]
+    rw_test(ints, "int", 16)
+  end
+
+  def test_rw_longs
+    longs = [-9223372036854775808, 9223372036854775807, -1, 0]
+    rw_test(longs, "long", 32)
+  end
+
+  def test_rw_uints
+    uints = [0xffffffff, 100000, 0]
+    rw_test(uints, "uint", 12)
+  end
+
+  def test_rw_ulongs
+    ulongs = [0xffffffffffffffff, 100000000000000, 0]
+    rw_test(ulongs, "ulong", 24)
+  end
+
+  def test_rw_vints
+    vints = [ 9223372036854775807,
+              0x00,
+              0xFFFFFFFFFFFFFFFF]
+    rw_test(vints, "vint", 20)
+  end
+
+  def test_rw_vlongs
+    vlongs = [ 9223372036854775807,
+               0x00,
+               0xFFFFFFFFFFFFFFFF]
+    rw_test(vlongs, "vlong", 20)
+  end
+
+  def test_rw_strings
+    text = 'This is a ruby ferret test string ~!@#$%^&*()`123456790-=\)_+|'
+    ostream = @dir.create_output("rw_strings.test")
+    ostream.write_string(text)
+    ostream.write_string(text*100)
+    ostream.close
+    istream = @dir.open_input("rw_strings.test")
+    assert_equal(text, istream.read_string, "Short string test failed")
+    assert_equal(text*100, istream.read_string, "Short string test failed")
+    istream.close
+    assert_equal(6265, @dir.length('rw_strings.test'))
+  end
+
+  def test_rw_utf8_strings
+    text = '³³ ÄÄÄÄÄÄ 道德經'
+    ostream = @dir.create_output("rw_utf8_strings.test")
+    ostream.write_string(text)
+    ostream.write_string(text*100)
+    ostream.close
+    istream = @dir.open_input("rw_utf8_strings.test")
+    assert_equal(text, x = istream.read_string, "Short string test failed")
+    assert_equal(text*100, istream.read_string, "Short string test failed")
+    istream.close
+  end
+
+  # this test fills up the output stream so that the buffer will have to be
+  # written a few times. It then uses seek to make sure that it works
+  # correctly
+  def test_buffer_seek
+    ostream = @dir.create_output("rw_seek.test")
+    text = 'This is another long test string !@#$%#$%&%$*%^&*()(_'
+    1000.times {|i| ostream.write_long(i); ostream.write_string(text) }
+    ostream.seek(987)
+    assert_equal(987, ostream.pos)
+    ostream.write_vint(555)
+    ostream.seek(56)
+    assert_equal(56, ostream.pos)
+    ostream.write_vint(1234567890)
+    ostream.seek(4000)
+    assert_equal(4000, ostream.pos)
+    ostream.write_vint(9876543210)
+    ostream.close()
+    istream = @dir.open_input("rw_seek.test")
+    istream.seek(56)
+    assert_equal(56, istream.pos)
+    assert_equal(1234567890, istream.read_vint())
+    istream.seek(4000)
+    assert_equal(4000, istream.pos)
+    assert_equal(9876543210, istream.read_vint())
+    istream.seek(987)
+    assert_equal(987, istream.pos)
+    assert_equal(555, istream.read_vint())
+    istream.close()
+  end
+
+  def test_clone
+    ostream = @dir.create_output("clone_test")
+    10.times {|i| ostream.write_long(i) }
+    ostream.close
+    istream = @dir.open_input("clone_test")
+    istream.seek(24)
+    alt_istream = istream.clone
+    assert_equal(istream.pos, alt_istream.pos)
+    (3...10).each {|i| assert_equal(i, alt_istream.read_long) }
+    assert_equal(80, alt_istream.pos)
+    assert_equal(24, istream.pos)
+    alt_istream.close
+    (3...10).each {|i| assert_equal(i, istream.read_long) }
+    istream.close
+  end
+
+  def test_read_bytes
+    str = "0000000000"
+    ostream = @dir.create_output("rw_read_bytes")
+    ostream.write_bytes("how are you doing?", 18)
+    ostream.close
+    istream = @dir.open_input("rw_read_bytes")
+    istream.read_bytes(str, 2, 4)
+    assert_equal("00how 0000", str)
+    istream.read_bytes(str, 1, 8)
+    assert_equal("0are you 0", str)
+    istream.close
+  end
+
+  private
+
+  def rw_test(values, type, expected_length)
+    ostream = @dir.create_output("rw_#{type}.test")
+    values.each { |b| ostream.__send__("write_" + type, b) }
+    ostream.close
+    istream = @dir.open_input("rw_#{type}.test")
+    values.each { |b| assert_equal(b, istream.__send__("read_" + type), "#{type} should be equal") }
+    istream.close
+    assert_equal(expected_length, @dir.length("rw_#{type}.test"))
+  end
+
+end

data/test/unit/store/rtm_store_lock.rb

@@ -0,0 +1,2 @@
+module StoreLockTest
+end

data/test/unit/store/tc_fs_store.rb

@@ -2,23 +2,6 @@ require File.dirname(__FILE__) + "/../../test_helper"
 require File.dirname(__FILE__) + "/tm_store"
 require File.dirname(__FILE__) + "/tm_store_lock"
 
-module Ferret::Store
-
-  class FSDirectory
-    def FSDirectory.directory_cache
-      @@Directories
-    end
-
-    def ref_count
-      @ref_count
-    end
-
-    def get_lock_prefix
-      lock_prefix
-    end
-  end
-end
-
 class FSStoreTest < Test::Unit::TestCase
   include Ferret::Store
   include StoreTest
@@ -27,6 +10,8 @@ class FSStoreTest < Test::Unit::TestCase
     @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
@@ -34,29 +19,58 @@ class FSStoreTest < Test::Unit::TestCase
     @dir.close()
   end
 
-  def test_cache
-    dir_path = File.join(File.dirname(__FILE__),
-                         '/../../temp/cachetest')
-    assert(! FSDirectory.directory_cache[dir_path],
-           "this directory should not be cached yet") 
-    @dir1 = FSDirectory.new(dir_path, true)
-    assert(FSDirectory.directory_cache[dir_path],
-           "this directory should now be cached") 
-    assert_equal(@dir1.ref_count, 1,
-                 "There is one reference so the refcount should now be 1")
-    @dir2 = FSDirectory.new(dir_path, true)
-    assert(@dir1 === @dir2,
-           "The directory should be cached so the same directory object should have been returned")
-    assert_equal(@dir1.ref_count, 2,
-                 "There are two references so the refcount should now be 2")
-    @dir1.close
-    assert(FSDirectory.directory_cache[dir_path],
-           "this directory shouldn't have been removed yet") 
-    assert_equal(@dir2.ref_count, 1,
-                 "There is one reference so the refcount should now be 1")
-    @dir2.close
-    assert(! FSDirectory.directory_cache[dir_path],
-           "this directory should have been removed from the cache") 
+  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/tc_ram_store.rb

@@ -12,4 +12,24 @@ class RAMStoreTest < Test::Unit::TestCase
   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/tm_store.rb

@@ -1,150 +1,34 @@
 module StoreTest
   # declare dir so inheritors can access it.
-  @dir = nil
-
-  def test_modified
-    # difficult to test this one but as file mtime is only stored to the nearest second.
-    # we can assume this test will happen in less than a few seconds. (I hope)
-    time = Time.new.to_i
-    @dir.touch('mtime.test')
-    time_before = @dir.modified('mtime.test').to_i
-    assert(time_before - time <= 3,
-           "test that mtime is approximately equal to the system time when the file was touched")
-  end
-
-  def test_rw_bytes
-    bytes = [0x34, 0x87, 0xF9, 0xEA, 0x00, 0xFF]
-    rw_test(bytes, "byte", 6)
-  end
-
-  def test_rw_ints
-    ints = [-2147483648, 2147483647, -1, 0]
-    rw_test(ints, "int", 16)
-  end
-
-  def test_rw_longs
-    longs = [-9223372036854775808, 9223372036854775807, -1, 0]
-    rw_test(longs, "long", 32)
-  end
-
-  def test_rw_uints
-    uints = [0xffffffff, 100000, 0]
-    rw_test(uints, "uint", 12)
-  end
-
-  def test_rw_ulongs
-    ulongs = [0xffffffffffffffff, 100000000000000, 0]
-    rw_test(ulongs, "ulong", 24)
-  end
-
-  def test_rw_vints
-    vints = [ 9223372036854775807,
-              0x00,
-              0xFFFFFFFFFFFFFFFF]
-    rw_test(vints, "vint", 20)
-  end
-
-  def test_rw_vlongs
-    vlongs = [ 9223372036854775807,
-               0x00,
-               0xFFFFFFFFFFFFFFFF]
-    rw_test(vlongs, "vlong", 20)
+  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
-
-  def test_rw_strings
-    text = 'This is a ruby ferret test string ~!@#$%^&*()`123456790-=\)_+|'
-    ostream = @dir.create_output("rw_strings.test")
-    ostream.write_string(text)
-    ostream.write_string(text*100)
-    ostream.close
-    istream = @dir.open_input("rw_strings.test")
-    assert_equal(text, istream.read_string, "Short string test failed")
-    assert_equal(text*100, istream.read_string, "Short string test failed")
-    istream.close
-    assert_equal(6265, @dir.length('rw_strings.test'))
-  end
-
-  def test_rw_utf8_strings
-    text = '³³ ÄÄÄÄÄÄ 道德經'
-    ostream = @dir.create_output("rw_utf8_strings.test")
-    ostream.write_string(text)
-    ostream.write_string(text*100)
-    ostream.close
-    istream = @dir.open_input("rw_utf8_strings.test")
-    assert_equal(text, x = istream.read_string, "Short string test failed")
-    assert_equal(text*100, istream.read_string, "Short string test failed")
-    istream.close
-  end
-
-  # this test fills up the output stream so that the buffer will have to be
-  # written a few times. It then uses seek to make sure that it works
-  # correctly
-  def test_buffer_seek
-    ostream = @dir.create_output("rw_seek.test")
-    text = 'This is another long test string !@#$%#$%&%$*%^&*()(_'
-    1000.times {|i| ostream.write_long(i); ostream.write_string(text) }
-    ostream.seek(987)
-    assert_equal(987, ostream.pos)
-    ostream.write_vint(555)
-    ostream.seek(56)
-    assert_equal(56, ostream.pos)
-    ostream.write_vint(1234567890)
-    ostream.seek(4000)
-    assert_equal(4000, ostream.pos)
-    ostream.write_vint(9876543210)
-    ostream.close()
-    istream = @dir.open_input("rw_seek.test")
-    istream.seek(56)
-    assert_equal(56, istream.pos)
-    assert_equal(1234567890, istream.read_vint())
-    istream.seek(4000)
-    assert_equal(4000, istream.pos)
-    assert_equal(9876543210, istream.read_vint())
-    istream.seek(987)
-    assert_equal(987, istream.pos)
-    assert_equal(555, istream.read_vint())
-    istream.close()
-  end
-
-  def test_clone
-    ostream = @dir.create_output("clone_test")
-    10.times {|i| ostream.write_long(i) }
-    ostream.close
-    istream = @dir.open_input("clone_test")
-    istream.seek(24)
-    alt_istream = istream.clone
-    assert_equal(istream.pos, alt_istream.pos)
-    (3...10).each {|i| assert_equal(i, alt_istream.read_long) }
-    assert_equal(80, alt_istream.pos)
-    assert_equal(24, istream.pos)
-    alt_istream.close
-    (3...10).each {|i| assert_equal(i, istream.read_long) }
-    istream.close
-  end
-
-  def test_read_bytes
-    str = "0000000000"
-    ostream = @dir.create_output("rw_read_bytes")
-    ostream.write_bytes("how are you doing?", 18)
-    ostream.close
-    istream = @dir.open_input("rw_read_bytes")
-    istream.read_bytes(str, 2, 4)
-    assert_equal("00how 0000", str)
-    istream.read_bytes(str, 1, 8)
-    assert_equal("0are you 0", str)
-    istream.close
-  end
-
-  private
-
-  def rw_test(values, type, expected_length)
-    ostream = @dir.create_output("rw_#{type}.test")
-    values.each { |b| ostream.__send__("write_" + type, b) }
-    ostream.close
-    istream = @dir.open_input("rw_#{type}.test")
-    values.each { |b| assert_equal(b, istream.__send__("read_" + type), "#{type} should be equal") }
-    istream.close
-    assert_equal(expected_length, @dir.length("rw_#{type}.test"))
-  end
-
 end