ferret 0.9.6 → 0.10.0

data/test/unit/store/tc_fs_store.rb

@@ -8,7 +8,7 @@ class FSStoreTest < Test::Unit::TestCase
   include StoreLockTest
   def setup
     @dpath = File.expand_path(File.join(File.dirname(__FILE__),
-                                        '../../temp/fsdir'))
+                       '../../temp/fsdir'))
     @dir = FSDirectory.new(@dpath, true)
   end
 

data/test/unit/store/tm_store_lock.rb

@@ -14,7 +14,7 @@ module StoreLockTest
     assert(lock1.obtain(lock_time_out))
     assert(lock2.locked?)
 
-    assert(! obtain_lock_true_false(lock2))
+    assert(! can_obtain_lock?(lock2))
 
     exception_thrown = false
     begin
@@ -46,7 +46,7 @@ module StoreLockTest
     while Switch.counter < 1
     end
     
-    assert(! obtain_lock_true_false(lock2))
+    assert(! can_obtain_lock?(lock2))
 
     Switch.counter = 2
     while Switch.counter < 3
@@ -56,7 +56,7 @@ module StoreLockTest
     lock2.release()
   end
 
-  def obtain_lock_true_false(lock)
+  def can_obtain_lock?(lock)
     lock_time_out = 0.001 # we want this test to run quickly
     begin
       lock.obtain(lock_time_out)

data/test/unit/tc_document.rb

@@ -0,0 +1,81 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+class DocumentTest < Test::Unit::TestCase
+  def test_field
+    f = Ferret::Field.new
+    assert_equal(0, f.size)
+    assert_equal(1.0, f.boost)
+
+    f2 = Ferret::Field.new
+    assert_equal(f, f2)
+
+    f << "section0"
+    assert_equal(1, f.size)
+    assert_equal(1.0, f.boost)
+    assert_equal("section0", f[0])
+    assert_not_equal(f, f2)
+
+    f << "section1"
+    assert_equal(2, f.size)
+    assert_equal(1.0, f.boost)
+    assert_equal("section0", f[0])
+    assert_equal("section1", f[1])
+    assert_equal('["section0", "section1"]', f.to_s)
+    assert_not_equal(f, f2)
+    f2 += f
+    assert_equal(f, f2)
+
+    f.boost = 4.0
+    assert_not_equal(f, f2)
+    assert_equal('["section0", "section1"]^4.0', f.to_s)
+
+    f2.boost = 4.0
+    assert_equal(f, f2)
+
+    f3 = Ferret::Field.new(["section0", "section1"], 4.0)
+    assert_equal(f, f3)
+  end
+
+  def test_document
+    d = Ferret::Document.new
+
+    d[:name] = Ferret::Field.new
+    d[:name] << "section0"
+    d[:name] << "section1"
+
+    assert_equal(1, d.size)
+    assert_equal(1.0, d.boost)
+    assert_equal(%(
+Document {
+  :name => ["section0", "section1"]
+}).strip, d.to_s)
+
+
+    d.boost = 123.0
+    d[:name] << "section2"
+    d[:name].boost = 321.0
+    assert_equal(123.0, d.boost)
+    assert_equal(321.0, d[:name].boost)
+    assert_equal(%(
+Document {
+  :name => ["section0", "section1", "section2"]^321.0
+}^123.0).strip, d.to_s)
+
+    d[:title] = "Shawshank Redemption"
+    d[:actors] = ["Tim Robbins", "Morgan Freeman"]
+
+    assert_equal(3, d.size)
+    assert_equal(%(
+Document {
+  :actors => ["Tim Robbins", "Morgan Freeman"]
+  :name => ["section0", "section1", "section2"]^321.0
+  :title => "Shawshank Redemption"
+}^123.0).strip, d.to_s)
+
+    d2 = Ferret::Document.new(123.0)
+    d2[:name] = Ferret::Field.new(["section0", "section1", "section2"], 321.0)
+    d2[:title] = "Shawshank Redemption"
+    d2[:actors] = ["Tim Robbins", "Morgan Freeman"]
+    assert_equal(d, d2)
+  end
+end

data/test/unit/ts_analysis.rb

@@ -1,2 +1,2 @@
 require File.join(File.dirname(__FILE__), "../test_helper.rb")
-load_test_dir('unit/analysis')
+load_test_dir('unit/utils')

data/test/unit/ts_utils.rb

@@ -1,2 +1,2 @@
 require File.join(File.dirname(__FILE__), "../test_helper.rb")
-load_test_dir('unit/utils')
+load_test_dir('unit/analysis')

data/test/unit/utils/tc_bit_vector.rb

@@ -0,0 +1,288 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+
+class BitVectorTest < Test::Unit::TestCase
+  include Ferret::Utils
+
+  def test_bv_get_set()
+    bv = BitVector.new
+    assert_equal 0, bv.count 
+
+    bv.set 10 
+    assert bv.get(10) 
+    assert bv[10] 
+    assert_equal 1, bv.count 
+
+    bv[10] = false
+    assert ! bv[10] 
+
+    bv[10] = true
+    assert bv[10] 
+
+    bv[10] = nil
+    assert ! bv[10] 
+
+    bv[10] = true
+    assert bv[10] 
+
+    bv.unset 10 
+    assert ! bv[10] 
+
+    bv[10] = true
+    assert bv[10] 
+  end
+
+  def test_bv_count()
+    bv = BitVector.new
+    bv.set 10 
+    assert_equal 1, bv.count 
+
+    bv.set 20 
+    assert bv.get(20) 
+    assert_equal 2, bv.count 
+
+    bv.set 21 
+    assert bv.get(21) 
+    assert_equal 3, bv.count 
+
+    bv.unset 21 
+    assert ! bv.get(21) 
+    assert_equal 2, bv.count 
+
+    bv[20] = nil
+    assert ! bv.get(20) 
+    assert_equal 1, bv.count 
+
+    (50..100).each {|i| bv.set i }
+    (50..100).each {|i| assert bv[i] }
+    assert bv.get(10) 
+    assert_equal 52, bv.count 
+
+    bv.clear
+    assert_equal 0, bv.count
+    (50..100).each {|i| assert ! bv[i] }
+    assert ! bv.get(10) 
+  end
+
+  def test_bv_eql_hash
+    bv1 = BitVector.new
+    bv2 = BitVector.new
+    assert_equal(bv1, bv2)
+    assert_equal(bv1.hash, bv2.hash)
+
+    bv1.set(10)
+    assert_not_equal(bv1, bv2)
+    assert_not_equal(bv1.hash, bv2.hash)
+
+    bv2.set(10)
+    assert_equal(bv1, bv2)
+    assert_equal(bv1.hash, bv2.hash)
+
+    10.times {|i| bv1.set(i * 31)}
+    assert_not_equal(bv1, bv2)
+    assert_not_equal(bv1.hash, bv2.hash)
+
+    10.times {|i| bv2.set(i * 31)}
+    assert_equal(bv1, bv2)
+    assert_equal(bv1.hash, bv2.hash)
+
+    bv1.clear
+    assert_not_equal(bv1, bv2)
+    assert_not_equal(bv1.hash, bv2.hash)
+
+    bv2.clear
+    assert_equal(bv1, bv2)
+    assert_equal(bv1.hash, bv2.hash)
+  end
+
+  BV_COUNT = 500
+  BV_SIZE = 1000
+
+  def test_bv_and
+    bv1 = BitVector.new
+    bv2 = BitVector.new
+    set1 = set2 = count = 0
+
+    BV_COUNT.times do |i|
+      bit = rand(BV_SIZE)
+      bv1.set(bit)
+      set1 |= (1 << bit)
+    end
+
+    BV_COUNT.times do |i|
+      bit = rand(BV_SIZE)
+      bv2.set(bit)
+      bitmask = (1 << bit)
+      if ((set1 & bitmask) > 0) && ((set2 & bitmask) == 0)
+        set2 |= (1 << bit)
+        count += 1
+      end
+    end
+
+    and_bv = bv1 & bv2
+    assert_equal(count, and_bv.count)
+    BV_SIZE.times do |i|
+      assert_equal(((set2 & (1 << i)) > 0), and_bv[i])
+    end
+
+    bv2.and! bv1
+    assert_equal(bv2, and_bv)
+
+    bv2 = BitVector.new
+    and_bv = bv1 & bv2
+
+    assert_equal(bv2, and_bv, "and_bv should be empty")
+    assert_equal(0, and_bv.count)
+  end
+  
+  def test_bv_or
+    bv1 = BitVector.new
+    bv2 = BitVector.new
+    set = count = 0
+
+    BV_COUNT.times do |i|
+      bit = rand(BV_SIZE)
+      bv1.set(bit)
+      bitmask = (1 << bit)
+      if (set & bitmask) == 0
+        count += 1
+        set |= bitmask
+      end
+    end
+
+    BV_COUNT.times do |i|
+      bit = rand(BV_SIZE)
+      bv2.set(bit)
+      bitmask = (1 << bit)
+      if (set & bitmask) == 0
+        count += 1
+        set |= bitmask
+      end
+    end
+
+    or_bv = bv1 | bv2
+    assert_equal(count, or_bv.count)
+    BV_SIZE.times do |i|
+      assert_equal(((set & (1 << i)) > 0), or_bv[i])
+    end
+
+    bv2.or! bv1
+    assert_equal(bv2, or_bv)
+
+    bv2 = BitVector.new
+    or_bv = bv1 | bv2
+
+    assert_equal(bv1, or_bv)
+  end
+  
+  def test_bv_xor
+    bv1 = BitVector.new
+    bv2 = BitVector.new
+    set1 = set2 = count = 0
+
+    BV_COUNT.times do |i|
+      bit = rand(BV_SIZE)
+      bv1.set(bit)
+      set1 |= (1 << bit)
+    end
+
+    BV_COUNT.times do |i|
+      bit = rand(BV_SIZE)
+      bv2.set(bit)
+      set2 |= (1 << bit)
+    end
+
+    bitmask = 1
+    set1 ^= set2
+    BV_SIZE.times do |i|
+      count += 1 if (set1 & bitmask) > 0
+      bitmask <<= 1
+    end
+
+    xor_bv = bv1 ^ bv2
+    BV_SIZE.times do |i|
+      assert_equal(((set1 & (1 << i)) > 0), xor_bv[i])
+    end
+    assert_equal(count, xor_bv.count)
+
+    bv2.xor! bv1
+    assert_equal(bv2, xor_bv)
+
+    bv2 = BitVector.new
+    xor_bv = bv1 ^ bv2
+
+    assert_equal(bv1, xor_bv)
+  end
+
+  def test_bv_not
+    bv = BitVector.new
+    [1, 5, 25, 41, 97, 185].each {|i| bv.set(i)}
+    not_bv = ~bv
+    assert_equal(bv.count, not_bv.count)
+    200.times {|i| assert(bv[i] != not_bv[i])}
+
+    not_bv.not!
+    assert_equal(bv, not_bv)
+  end
+
+
+  SCAN_SIZE = 200
+  SCAN_INC = 97
+
+  def test_scan
+    bv = BitVector.new
+
+    SCAN_SIZE.times {|i| bv.set(i * SCAN_INC)}
+    not_bv = ~bv
+
+    SCAN_SIZE.times do |i|
+      assert_equal(i * SCAN_INC, bv.next_from((i - 1) * SCAN_INC + 1))
+      assert_equal(i * SCAN_INC, not_bv.next_unset_from((i - 1) * SCAN_INC + 1))
+    end
+    assert_equal(-1, bv.next_from((SCAN_SIZE - 1) * SCAN_INC + 1))
+    assert_equal(-1, not_bv.next_unset_from((SCAN_SIZE - 1) * SCAN_INC + 1))
+
+    bit = 0
+    bv.each {|i| assert_equal(bit, i); bit += SCAN_INC }
+    assert_equal(bit, SCAN_SIZE * SCAN_INC)
+
+    bit = 0
+    not_bv.each {|i| assert_equal(bit, i); bit += SCAN_INC }
+    assert_equal(bit, SCAN_SIZE * SCAN_INC)
+
+    bv.reset_scan
+    not_bv.reset_scan
+    SCAN_SIZE.times do |i|
+      assert_equal(i * SCAN_INC, bv.next)
+      assert_equal(i * SCAN_INC, not_bv.next_unset)
+    end
+    assert_equal(-1, bv.next)
+    assert_equal(-1, not_bv.next_unset)
+
+    bv.clear
+    SCAN_SIZE.times {|i| bv.set(i)}
+    not_bv = ~bv
+
+    SCAN_SIZE.times do |i|
+      assert_equal(i, bv.next)
+      assert_equal(i, not_bv.next_unset)
+    end
+    assert_equal(-1, bv.next)
+    assert_equal(-1, not_bv.next_unset)
+
+    bit = 0
+    bv.each {|i| assert_equal(bit, i); bit += 1 }
+    assert_equal(bit, SCAN_SIZE)
+
+    bit = 0
+    not_bv.each {|i| assert_equal(bit, i); bit += 1 }
+    assert_equal(bit, SCAN_SIZE)
+  end
+
+  def test_to_a
+    bv = BitVector.new
+    ary = (1..100).collect { rand(1000) }.sort.uniq
+    ary.each {|i| bv.set(i)}
+    assert_equal(ary, bv.to_a)
+  end
+end

data/test/unit/utils/tc_number_tools.rb

@@ -0,0 +1,117 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+require 'ferret/number_tools'
+
+
+class NumberToolsTest < Test::Unit::TestCase
+  include Ferret::Utils
+
+  def test_to_i_lex_near_zero()
+    (-10..10).each do |num|
+      assert(num.to_s_lex > (num-1).to_s_lex,
+             "Strings should sort correctly but " +
+             "#{num.to_s_lex} <= #{(num-1).to_s_lex}")
+      assert_equal(num, num.to_s_lex.to_i_lex)
+    end
+  end
+
+  def test_to_i_pad_near_zero()
+    (1..10).each do |num|
+      assert(num.to_s_pad(3) > (num-1).to_s_pad(3),
+             "Strings should sort correctly but " +
+             "#{num.to_s_pad(3)} <= #{(num-1).to_s_pad(3)}")
+      assert_equal(num, num.to_s_pad(3).to_i)
+    end
+  end
+
+  def test_to_i_lex_larger_numbers
+    100.times do
+      num1 = rand(10000000000000000000000000000000000)
+      num2 = rand(10000000000000000000000000000000000)
+      num1 *= -1 if rand(2) == 0
+      num2 *= -1 if rand(2) == 0
+
+      assert_equal(num1, num1.to_s_lex.to_i_lex)
+      assert_equal(num2, num2.to_s_lex.to_i_lex)
+      assert_equal(num1 < num2, num1.to_s_lex < num2.to_s_lex, 
+                   "Strings should sort correctly but " +
+                   "#{num1} < #{num2} == #{num1 < num2} but " +
+                   "#{num1.to_s_lex} < #{num2.to_s_lex} == " +
+                   "#{num1.to_s_lex < num2.to_s_lex}")
+    end
+  end
+
+  def test_to_i_pad
+    100.times do
+      num1 = rand(10000000000000000000000000000000000)
+      num2 = rand(10000000000000000000000000000000000)
+      assert_equal(num1, num1.to_s_pad(35).to_i)
+      assert_equal(num2, num2.to_s_pad(35).to_i)
+      assert_equal(num1 < num2, num1.to_s_pad(35) < num2.to_s_pad(35), 
+                   "Strings should sort correctly but " +
+                   "#{num1} < #{num2} == #{num1 < num2} but " +
+                   "#{num1.to_s_pad(35)} < #{num2.to_s_pad(35)} == " +
+                   "#{num1.to_s_pad(35) < num2.to_s_pad(35)}")
+    end
+  end
+  
+  def test_time_to_s_lex
+    t_num = Time.now.to_i
+
+    10.times do
+      t1 = Time.now - rand(t_num)
+      t2 = Time.now - rand(t_num)
+      assert_equal(t1.to_s, t1.to_s_lex(:second).to_time_lex.to_s)
+      assert_equal(t2.to_s, t2.to_s_lex(:second).to_time_lex.to_s)
+      [:year, :month, :day, :hour, :minute, :second, :millisecond].each do |prec|
+        t1_x = t1.to_s_lex(prec).to_time_lex
+        t2_x = t2.to_s_lex(prec).to_time_lex
+        assert_equal(t1_x < t2_x, t1.to_s_lex(prec) < t2.to_s_lex(prec), 
+                     "Strings should sort correctly but " +
+                     "#{t1_x} < #{t2_x} == #{t1_x < t2_x} but " +
+                     "#{t1.to_s_lex(prec)} < #{t2.to_s_lex(prec)} == " +
+                     "#{t1.to_s_lex(prec) < t2.to_s_lex(prec)}")
+      end
+    end
+  end
+
+  def test_date_to_s_lex
+    10.times do
+      d1 = Date.civil(rand(2200), rand(12) + 1, rand(28) + 1)
+      d2 = Date.civil(rand(2200), rand(12) + 1, rand(28) + 1)
+      assert_equal(d1.to_s, d1.to_s_lex(:day).to_date_lex.to_s)
+      assert_equal(d2.to_s, d2.to_s_lex(:day).to_date_lex.to_s)
+      [:year, :month, :day].each do |prec|
+        d1_x = d1.to_s_lex(prec).to_date_lex
+        d2_x = d2.to_s_lex(prec).to_date_lex
+        assert_equal(d1_x < d2_x, d1.to_s_lex(prec) < d2.to_s_lex(prec), 
+                     "Strings should sort correctly but " +
+                     "#{d1_x} < #{d2_x} == #{d1_x < d2_x} but " +
+                     "#{d1.to_s_lex(prec)} < #{d2.to_s_lex(prec)} == " +
+                     "#{d1.to_s_lex(prec) < d2.to_s_lex(prec)}")
+      end
+
+    end
+  end
+
+  def test_date_time_to_s_lex
+    10.times do
+      d1 = DateTime.strptime("#{rand(2200)}-#{rand(12)+1}-#{rand(28)+1} "+
+                             "#{rand(24)}:#{rand(60)}:#{rand(60)}",
+                             "%Y-%m-%d %H:%M:%S")
+      d2 = DateTime.strptime("#{rand(2200)}-#{rand(12)+1}-#{rand(28)+1} "+
+                             "#{rand(24)}:#{rand(60)}:#{rand(60)}",
+                             "%Y-%m-%d %H:%M:%S")
+      assert_equal(d1.to_s, d1.to_s_lex(:second).to_date_time_lex.to_s)
+      assert_equal(d2.to_s, d2.to_s_lex(:second).to_date_time_lex.to_s)
+      [:year, :month, :day, :hour, :minute, :second].each do |prec|
+        d1_x = d1.to_s_lex(prec).to_date_lex
+        d2_x = d2.to_s_lex(prec).to_date_lex
+        assert_equal(d1_x < d2_x, d1.to_s_lex(prec) < d2.to_s_lex(prec), 
+                     "Strings should sort correctly but " +
+                     "#{d1_x} < #{d2_x} == #{d1_x < d2_x} but " +
+                     "#{d1.to_s_lex(prec)} < #{d2.to_s_lex(prec)} == " +
+                     "#{d1.to_s_lex(prec) < d2.to_s_lex(prec)}")
+      end
+    end
+  end
+end