ferret 0.9.6 → 0.10.0

data/test/unit/store/rtm_store_lock.rb

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

data/test/unit/ts_document.rb

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

data/test/unit/utils/rtc_bit_vector.rb

@@ -1,73 +0,0 @@
-require File.dirname(__FILE__) + "/../../test_helper"
-
-
-class BitVectorTest < Test::Unit::TestCase
-  include Ferret::Utils
-
-  def test_bignum_conversion()
-    j = 256
-    10.times do
-      j *= j
-      assert_equal(j, BitVector.string_to_bignum(BitVector.bignum_to_string(j)))
-    end
-  end
-
-  def test_bv()
-    bv = BitVector.new
-    assert_equal(0, bv.count)
-    bv.set(10)
-    assert(bv.get(10))
-    assert_equal(1, bv.count)
-    bv.set(10)
-    assert(bv.get(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.clear(21)
-    assert(!bv.get(21))
-    assert_equal(2, bv.count)
-    bv.clear(20)
-    assert(!bv.get(20))
-    assert_equal(1, bv.count)
-    assert(bv.get(10))
-  end
-
-  def test_bv_rw()
-    dir = Ferret::Store::RAMDirectory.new
-    bv = BitVector.new
-    assert_equal(0, bv.count)
-    bv.set(5)
-    assert_equal(1, bv.count)
-    bv.set(8)
-    assert_equal(2, bv.count)
-    bv.set(13)
-    assert_equal(3, bv.count)
-    bv.set(21)
-    assert_equal(4, bv.count)
-    bv.set(34)
-    assert_equal(5, bv.count)
-    bv.write(dir, "bv.test")
-    bv = nil
-    bv = BitVector.read(dir, "bv.test")
-    assert(!bv.get(4))
-    assert(bv.get(5))
-    assert(!bv.get(6))
-    assert(!bv.get(7))
-    assert(bv.get(8))
-    assert(!bv.get(9))
-    assert(!bv.get(12))
-    assert(bv.get(13))
-    assert(!bv.get(14))
-    assert(!bv.get(20))
-    assert(bv.get(21))
-    assert(!bv.get(22))
-    assert(!bv.get(33))
-    assert(bv.get(34))
-    assert(!bv.get(35))
-    assert_equal(5, bv.count)
-  end
-end

data/test/unit/utils/rtc_date_tools.rb

@@ -1,50 +0,0 @@
-require File.dirname(__FILE__) + "/../../test_helper"
-
-
-class DateToolsTest < Test::Unit::TestCase
-  include Ferret::Utils
-
-  def test_serialization()
-    # grab time to the nearest millisecond
-    t = Time.at((Time.now().to_i*1000).floor()/1000)
-
-    s = DateTools.serialize_time(t)
-
-    t_after = DateTools.deserialize_time(s)
-    assert_equal(t, t_after, "date changed after serialization")
-  end
-  
-  def test_serialization_constants()
-    # assert existance of these constants
-    assert(DateTools::MAX_SERIALIZED_DATE_STRING)
-    assert(DateTools::MIN_SERIALIZED_DATE_STRING)
-  end
-
-  def test_time_to_s()
-    t = Time.mktime(2004, 9, 5, 22, 33, 44, 555000)
-
-    assert_equal("2004", DateTools.time_to_s(t, DateTools::Resolution::YEAR))
-    assert_equal("200409", DateTools.time_to_s(t, DateTools::Resolution::MONTH))
-    assert_equal("20040905", DateTools.time_to_s(t, DateTools::Resolution::DAY))
-    assert_equal("2004090522", DateTools.time_to_s(t, DateTools::Resolution::HOUR))
-    assert_equal("200409052233", DateTools.time_to_s(t, DateTools::Resolution::MINUTE))
-    assert_equal("20040905223344", DateTools.time_to_s(t, DateTools::Resolution::SECOND))
-    assert_equal("20040905223344555", DateTools.time_to_s(t, DateTools::Resolution::MILLISECOND))
-  end
-
-  def test_s_to_time()
-    assert_equal(Time.mktime(2004), DateTools.s_to_time("2004"))
-    assert_equal(Time.mktime(2004, 9), DateTools.s_to_time("200409"))
-    assert_equal(Time.mktime(2004, 9, 5), DateTools.s_to_time("20040905"))
-    assert_equal(Time.mktime(2004, 9, 5, 22), DateTools.s_to_time("2004090522"))
-    assert_equal(Time.mktime(2004, 9, 5, 22, 33), DateTools.s_to_time("200409052233"))
-    assert_equal(Time.mktime(2004, 9, 5, 22, 33, 44), DateTools.s_to_time("20040905223344"))
-    assert_equal(Time.mktime(2004, 9, 5, 22, 33, 44, 555000), DateTools.s_to_time("20040905223344555"))
-  end
-
-  def test_round()
-    t = Time.mktime(2004, 9, 5, 22, 33, 44, 555000)
-    assert_equal(Time.mktime(2004, 9, 5), DateTools.round(t, DateTools::Resolution::DAY))
-  end
-
-end

data/test/unit/utils/rtc_number_tools.rb

@@ -1,59 +0,0 @@
-require File.dirname(__FILE__) + "/../../test_helper"
-
-
-class NumberToolsTest < Test::Unit::TestCase
-  include Ferret::Utils
-
-  def test_near_zero()
-    2.times() do |i|
-      2.times() { |j| subtest_two_longs(i, j) }
-    end
-  end
-
-  def test_max()
-    # make sure the constants convert to their equivelents
-    assert_equal(NumberTools::LONG_MAX_VALUE, NumberTools.s_to_long(NumberTools::MAX_STRING_VALUE))
-    assert_equal(NumberTools::MAX_STRING_VALUE, NumberTools.long_to_s(NumberTools::LONG_MAX_VALUE))
-    # test near MAX, too
-
-    l = NumberTools::LONG_MAX_VALUE
-    subtest_two_longs(l, l - 1)
-  end
-
-  def test_min()
-    # make sure the constants convert to their equivelents
-    assert_equal(NumberTools::LONG_MIN_VALUE, NumberTools.s_to_long(NumberTools::MIN_STRING_VALUE))
-    assert_equal(NumberTools::MIN_STRING_VALUE, NumberTools.long_to_s(NumberTools::LONG_MIN_VALUE))
-
-    # test near MIN, too
-    l = NumberTools::LONG_MIN_VALUE
-    subtest_two_longs(l, l + 1)
-  end
-
-  def subtest_two_longs(i, j)
-    # convert to strings
-    a = NumberTools.long_to_s(i)
-    b = NumberTools.long_to_s(j)
-
-    # are they the right length?
-    assert_equal(NumberTools::STR_SIZE, a.length())
-    assert_equal(NumberTools::STR_SIZE, b.length())
-
-    # are they the right order?
-    if (i < j)
-        assert(a < b)
-    elsif (i > j)
-        assert(a > b)
-    else
-        assert_equal(a, b)
-    end
-
-    # can we convert them back to longs?
-    i2 = NumberTools.s_to_long(a)
-    j2 = NumberTools.s_to_long(b)
-
-    assert_equal(i, i2)
-    assert_equal(j, j2)
-  end
-
-end

data/test/unit/utils/rtc_parameter.rb

@@ -1,40 +0,0 @@
-require File.dirname(__FILE__) + "/../../test_helper"
-
-
-class ParameterTest < Test::Unit::TestCase
-  include Ferret::Utils
-
-  class Param1 < Parameter
-    VAL1 = Param1.new("VAL")
-  end
-
-  class Param2 < Parameter
-    VAL1 = Param2.new("VAL")
-  end
-
-  def test_parameter_cmp()
-    assert_raise(ArgumentError) do
-      class <<Param1
-         v = Param1.new("VAL")
-      end
-    end
-    assert_raise(ArgumentError) do
-      class <<Param1
-         v = Param2.new("VAL")
-      end
-    end
-      
-    p1 = Param1::VAL1
-    p2 = Param1::VAL1
-    p3 = Param2::VAL1
-    assert_equal(p1, p2)
-    assert_not_equal(p1, p3)
-  end
-
-  def test_marshalling()
-    p1 = Param1::VAL1
-    data = Marshal.dump(p1)
-    p2 = Marshal.load(data)
-    assert_equal(p1, p2)
-  end
-end

data/test/unit/utils/rtc_priority_queue.rb

@@ -1,62 +0,0 @@
-require File.dirname(__FILE__) + "/../../test_helper"
-
-
-class PriorityQueueTest < Test::Unit::TestCase
-  include Ferret::Utils
-
-  PQ_STRESS_SIZE = 1000
-
-  def test_pq()
-    pq = PriorityQueue.new(4)
-    assert_equal(0, pq.size)
-    pq.push("bword")
-    assert_equal(1, pq.size)
-    assert_equal("bword", pq.top)
-    pq.push("cword")
-    assert_equal(2, pq.size)
-    assert_equal("bword", pq.top)
-    pq.push("aword")
-    assert_equal(3, pq.size)
-    assert_equal("aword", pq.top)
-    pq.push("dword")
-    assert_equal(4, pq.size)
-    assert_equal("aword", pq.top)
-    assert_equal("aword", pq.pop())
-    assert_equal(3, pq.size)
-    assert_equal("bword", pq.pop())
-    assert_equal(2, pq.size)
-    assert_equal("cword", pq.pop())
-    assert_equal(1, pq.size)
-    assert_equal("dword", pq.pop())
-    assert_equal(0, pq.size)
-  end
-
-  def test_pq_clear()
-    pq = PriorityQueue.new(3)
-    pq.push("word1")
-    pq.push("word2")
-    pq.push("word3")
-    assert_equal(3, pq.size)
-    pq.clear()
-    assert_equal(0, pq.size)
-  end
-
-
-  #define PQ_STRESS_SIZE 1000
-  def test_stress_pq()
-    pq = PriorityQueue.new(PQ_STRESS_SIZE)
-    PQ_STRESS_SIZE.times do
-      pq.push("<#{(rand * PQ_STRESS_SIZE).to_i}>")
-    end
-
-    prev = pq.pop()
-    (PQ_STRESS_SIZE - 1).times do
-      curr = pq.pop()
-      if (prev > curr)
-        assert(prev <= curr, "previous #{prev} should be less than current #{curr}")
-      end
-      prev = curr
-    end
-    pq.clear()
-  end
-end

data/test/unit/utils/rtc_string_helper.rb

@@ -1,21 +0,0 @@
-require File.dirname(__FILE__) + "/../../test_helper"
-
-
-class StringHelperTest < Test::Unit::TestCase
-  include Ferret::Utils
-
-  def test_string_difference()
-    assert_equal(3, StringHelper.string_difference("David", "Dave"))
-    assert_equal(0, StringHelper.string_difference("David", "Erik"))
-    assert_equal(4, StringHelper.string_difference("book", "bookworm"))
-  end
-
-  def test_string_reader
-    sr = StringHelper::StringReader.new("TestString")
-    assert_equal("T", sr.read(1))
-    assert_equal("es", sr.read(2))
-    assert_equal("tStr", sr.read(4))
-    assert_equal("ing", sr.read(100))
-    assert_nil(sr.read(100))
-  end
-end

data/test/unit/utils/rtc_thread.rb

@@ -1,61 +0,0 @@
-require File.dirname(__FILE__) + "/../../test_helper"
-require 'thread'
-
-
-class ThreadTest < Test::Unit::TestCase
-  include Ferret::Utils
-
-  NUM_THREADS = 100
-
-  def test_basic_get_and_set()
-    Thread.current.clear_local
-    b = "hello"
-    Thread.current.set_local(b, "dave")
-    assert_equal("dave", Thread.current.get_local(b))
-  end
-
-  def test_objects_die
-    Thread.current.clear_local
-    a = []
-    10.times {|i| a[i] = "#{i}"; Thread.current.set_local(a[i], i) }
-    10.times {|i| assert_equal(i, Thread.current.get_local(a[i])) }
-    assert_equal(10, Thread.current.local_size)
-    GC.start
-    assert_equal(10, Thread.current.local_size)
-    10.times {|i| a[i] = nil; }
-    #puts w
-    
-    # this is a hack to get the GC to collect the last ref created above
-    x = WeakKeyHash.new()
-    10.times {|i| a[i] = "#{i}"; x[a[i]] = i }
-
-    assert_equal(10, Thread.current.local_size)
-    GC.start
-    assert(0, Thread.current.local_size)
-  end
-
-  class ThreadTester
-    def initialize(val)
-      Thread.current.set_local(self, val)
-    end
-    def inc
-      val = Thread.current.get_local(self) + 1
-      Thread.current.set_local(self, val)
-      return val
-    end
-  end
-
-  def single_thread
-    tt = ThreadTester.new(start = rand(10000000))
-    ((start+1)..start+11).each {|i| assert_equal(i, tt.inc) }
-  end
-
-  def test_threads_dont_share
-    threads = []
-    NUM_THREADS.times do
-      threads << Thread.new { single_thread }
-    end
-
-    threads.each {|t| t.join}
-  end
-end

data/test/unit/utils/rtc_weak_key_hash.rb

@@ -1,25 +0,0 @@
-require File.dirname(__FILE__) + "/../../test_helper"
-
-
-class WeakKeyHashTest < Test::Unit::TestCase
-  include Ferret::Utils
-
-  def test_objects_are_destroyed()
-    w = WeakKeyHash.new()
-    a = []
-    10.times {|i| a[i] = "#{i}"; w[a[i]] = i }
-    10.times {|i| assert_equal(i, w[a[i]]) }
-    assert_equal(10, w.size)
-    10.times {|i| a[i] = nil; }
-    #puts w
-    
-    # this is a hack to get the GC to collect the last ref created above
-    x = WeakKeyHash.new()
-    10.times {|i| a[i] = "#{i}"; x[a[i]] = i }
-
-    GC.start
-    #puts w.size
-    #puts w
-    assert(0, w.size)
-  end
-end

data/test/utils/number_to_spoken.rb

@@ -1,132 +0,0 @@
-# Author: Matthew D Moss
-#
-# Writtern for ruby quiz #25
-#
-class JapaneseTranslator
-    # My knowledge of counting Japanese is limited, so this may not
-    # be entirely correct; in particular, I don't know what rules
-    # to follow after 'hyaku man' (1,000,000).
-    # I also combine a digit with its group, such as 'gohyaku' rather
-    # than 'go hyaku'; I just like reading it better that way.
-
-    DIGITS = %w(zero ichi ni san yon go roku nana hachi kyu)
-    GROUPS = %w(nothingtoseeheremovealong ju hyaku sen)
-    MAN = 10000
-
-    def to_spoken(val)
-        case val <=> 0
-        when -1
-            '- ' + to_spoken(-val)
-        when 0
-            DIGITS[0]
-        else
-            group(val, 0)
-        end
-    end
-
-    private
-
-    def group(val, level)
-        if val >= MAN
-            group(val / MAN, 0) + 'man ' + group(val % MAN, 0)
-        else
-            case val
-            when 0
-                ''
-            when 1
-                level == 0 ? DIGITS[val] : GROUPS[level]
-            when 2...10
-                DIGITS[val] + (GROUPS[level] if level > 0).to_s
-            else
-                group(val / 10, level+1) + ' ' + group(val % 10, level)
-            end
-        end
-    end
-end
-
-
-class USEnglishTranslator
-    # Formal, US English. Optional 'and'. Will not produce things
-    # such as 'twelve hundred' but rather 'one thousand two hundred'.
-    # The use of 'and' is incomplete; it is sometimes missed.
-
-    DIGITS = %w(zero one two three four five six seven eight nine)
-    TEENS  = %w(ten eleven twelve thirteen fourteen fifteen sixteen
-                seventeen eighteen nineteen)
-    TENS   = %w(hello world twenty thirty forty fifty sixty seventy
-                eighty ninety)
-    GROUPS = %w(thousand million billion trillion quadrillion
-                quintillion sextillion septillion octillion nonillion
-                decillion)
-    K = 1000
-
-    def initialize(conjunction = true)
-        @conjunction = conjunction
-    end
-
-    def to_spoken(val)
-        case val <=> 0
-        when -1
-            'negative ' + to_spoken(-val)
-        when 0
-            DIGITS[0]
-        else
-            group(val, 0).flatten.join(' ')
-        end
-    end
-
-    private
-
-    def group(val, level)
-        x = group(val / K, level + 1) << GROUPS[level] if val >= K
-        x.to_a << under_1000(val % K, level)
-    end
-
-    def under_1000(val, level)
-        x = [DIGITS[val / 100]] << 'hundred' if val >= 100
-        x.to_a << under_100(val % 100, (level == 0 and not x.nil?))
-    end
-
-    def under_100(val, junction)
-        x = [('and' if @conjunction and junction)]    # wyf?
-        case val
-        when 0
-            []
-        when 1...10
-            x << DIGITS[val]
-        when 10...20
-            x << TEENS[val - 10]
-        else
-            d = val % 10
-            x << (TENS[val / 10] + ('-' + DIGITS[d] if d != 0).to_s)
-        end
-    end
-end
-
-
-class Integer
-    def to_spoken(translator = USEnglishTranslator.new)
-        translator.to_spoken(self).squeeze(' ').strip
-    end
-end
-
-if $0 == __FILE__
-    SAMPLES = [ 0, 1, 2, 5, 10, 11, 14, 18, 20, 21, 29, 33, 42, 50, 87, 99,
-                100, 101, 110, 167, 199, 200, 201, 276, 300, 314, 500, 610,
-                1000, 1039, 1347, 2309, 3098, 23501, 32767, 70000, 5480283,
-                2435489238, 234100090000, -42, -2001 ]
-
-    TRANSLATORS = { 'US English' => USEnglishTranslator.new,
-                    'Japanese'   => JapaneseTranslator.new }
-
-
-    # main
-    TRANSLATORS.each do |lang, translator|
-        puts
-        puts lang
-        puts '-' * lang.length
-        SAMPLES.each do |val|
-            puts "%12d => %s" % [val, val.to_spoken(translator)]
-        end
-    end
-end