higgs 0.1.0

data/test/test_cgi_session.rb

@@ -0,0 +1,142 @@
+#!/usr/local/bin/ruby
+
+require 'cgi/session/higgs'
+require 'cgi/session/pstore'
+require 'fileutils'
+require 'logger'
+require 'test/unit'
+
+module Higgs::Test
+  module CGISessionTest
+    # for ident(1)
+    CVS_ID = '$Id: test_cgi_session.rb 560 2007-09-25 15:34:24Z toki $'
+
+    def new_store(session, options={})
+      options.update('tmpdir' => @tmpdir, :logger => @logger)
+      store_type.new(session, options)
+    end
+
+    def setup
+      @tmpdir = 'cgi_tmp'
+      FileUtils.rm_rf(@tmpdir) if $DEBUG
+      FileUtils.mkdir_p(@tmpdir)
+      @logger = proc{|path|
+        logger = Logger.new(path, 1)
+        logger.level = Logger::WARN
+        logger
+      }
+      @session = Object.new
+      class << @session
+        attr_accessor :session_id
+        attr_accessor :new_session
+      end
+      @session.session_id = 'foo'
+      @session.new_session = true
+      @store = new_store(@session)
+    end
+
+    def teardown
+      @store.close
+      FileUtils.rm_rf(@tmpdir) unless $DEBUG
+    end
+
+    def test_restore_update_close
+      hash = @store.restore
+      hash['key'] = { 'k' => 'v' }
+      @store.update
+      @store.close
+
+      @store = new_store(@session)
+      assert_equal({ 'key' => { 'k' => 'v' } }, @store.restore)
+    end
+
+    def test_delete
+      hash = @store.restore
+      hash['key'] = { 'k' => 'v' }
+      @store.update
+      @store.delete
+
+      @store = new_store(@session)
+      assert_equal({}, @store.restore)
+    end
+
+    def test_not_new_session
+      @store.delete
+
+      @session.new_session = false
+      assert_raise(CGI::Session::NoSession) {
+        @store = new_store(@session)
+      }
+    end
+
+    def test_multiproc_counter
+      @store.close
+      num_of_procs = 2
+      count_by_proc = 1000
+      pid_list = []
+      ready_latch = File.join(@tmpdir, '.ready_latch')
+      start_latch = File.join(@tmpdir, '.start_latch')
+
+      begin
+        num_of_procs.times do |i|
+          pid_list << fork{
+            FileUtils.touch("#{ready_latch}.#{i}")
+            until (File.exist? start_latch)
+              # spin lock
+            end
+            count_by_proc.times do
+              @store = new_store(@session)
+              hash = @store.restore
+              hash['count'] = (hash['count'] || 0).succ
+              @store.close
+            end
+          }
+        end
+
+        num_of_procs.times do |i|
+          until (File.exist? "#{ready_latch}.#{i}")
+            # spin lock
+          end
+        end
+        FileUtils.touch(start_latch)
+
+        for pid in pid_list
+          Process.waitpid(pid)
+        end
+
+        @store = new_store(@session)
+        assert_equal(num_of_procs * count_by_proc, @store.restore['count'])
+      ensure
+        num_of_procs.times do |i|
+          FileUtils.rm_f("#{ready_latch}.#{i}")
+        end
+        FileUtils.rm_f(start_latch)
+      end
+    end
+  end
+
+  class CGISessionPstoreTest < Test::Unit::TestCase
+    include CGISessionTest
+
+    # for ident(1)
+    CVS_ID = '$Id: test_cgi_session.rb 560 2007-09-25 15:34:24Z toki $'
+
+    def store_type
+      CGI::Session::PStore
+    end
+
+    # race condition
+    undef test_multiproc_counter
+  end
+
+  class CGISessionHiggsStoreTest < Test::Unit::TestCase
+    include CGISessionTest
+
+    # for ident(1)
+    CVS_ID = '$Id: test_cgi_session.rb 560 2007-09-25 15:34:24Z toki $'
+
+    def store_type
+      CGI::Session::HiggsStore
+    end
+  end
+end

data/test/test_flock.rb

@@ -0,0 +1,162 @@
+#!/usr/local/bin/ruby
+
+require 'fileutils'
+require 'higgs/flock'
+require 'test/unit'
+
+module Higgs::Test
+  class FileLockTest < Test::Unit::TestCase
+    include Higgs
+
+    # for ident(1)
+    CVS_ID = '$Id: test_flock.rb 559 2007-09-25 15:20:20Z toki $'
+
+    def setup
+      @test_dir = 'flock_test'
+      FileUtils.rm_rf(@test_dir) # for debug
+      FileUtils.mkdir_p(@test_dir)
+      @count_path = File.join(@test_dir, 'count')
+      @lock_path = File.join(@test_dir, 'lock')
+    end
+
+    def teardown
+      FileUtils.rm_rf(@test_dir) unless $DEBUG
+    end
+
+    def make_flock(*args)
+      flock = FileLock.new(@lock_path, *args)
+      begin
+        yield(flock)
+      ensure
+        flock.close
+      end
+    end
+    private :make_flock
+
+    def test_write_lock_single_process
+      make_flock{|flock|
+        File.open(@count_path, 'w') {|f| f << '0' }
+        100.times do
+          flock.synchronize(:EX) {
+            value = IO.read(@count_path)
+            value.succ!
+            File.open(@count_path, 'w') {|f| f << value }
+          }
+        end
+        assert_equal('100', IO.read(@count_path))
+      }
+    end
+
+    def test_write_lock_multi_process
+      File.open(@count_path, 'w') {|f| f << '0' }
+
+      writers = 10
+      each_count = 1000
+      w_pid_list = []
+
+      writers.times do |i|
+        w_pid_list << fork{
+          make_flock{|flock|
+            each_count.times do
+              flock.synchronize(:EX) {
+                value = IO.read(@count_path)
+                value.succ!
+                File.open(@count_path, 'w') {|f| f << value }
+              }
+            end
+          }
+        }
+      end
+
+      w_st_list = []
+      for w_pid in w_pid_list
+        Process.waitpid(w_pid)
+        w_st_list << $?.exitstatus
+      end
+
+      w_st_list.each_with_index do |exitstatus, i|
+        assert_equal(0, exitstatus, "writer process: #{i}")
+      end
+
+      assert_equal(writers * each_count, IO.read(@count_path).to_i)
+    end
+
+    def test_read_write_lock_multi_process
+      File.open(@count_path, 'w') {|f| f << '0' }
+
+      writers = 3
+      readers = 10
+      each_count = 1000
+      w_pid_list = []
+      r_pid_list = []
+
+      writers.times do |i|
+        w_pid_list << fork{
+          make_flock{|flock|
+            each_count.times do
+              flock.synchronize(:EX) {
+                File.open(@count_path, 'w') {|f| f << '1' }
+                File.open(@count_path, 'w') {|f| f << '0' }
+              }
+            end
+          }
+        }
+      end
+
+      readers.times do |i|
+        r_pid_list << fork{
+          make_flock(true) {|flock|
+            each_count.times do
+              flock.synchronize(:SH) {
+                assert_equal('0', IO.read(@count_path))
+              }
+            end
+          }
+        }
+      end
+
+      w_st_list = []
+      for w_pid in w_pid_list
+        Process.waitpid(w_pid)
+        w_st_list << $?.exitstatus
+      end
+
+      r_st_list = []
+      for r_pid in r_pid_list
+        Process.waitpid(r_pid)
+        r_st_list << $?.exitstatus
+      end
+
+      w_st_list.each_with_index do |exitstatus, i|
+        assert_equal(0, exitstatus, "writer process: #{i}")
+      end
+
+      r_st_list.each_with_index do |exitstatus, i|
+        assert_equal(0, exitstatus, "reader process: #{i}")
+      end
+    end
+
+    def test_read_only_lock_failed_to_write_lock
+      make_flock(true) {|flock|
+        assert_raise(RuntimeError) {
+          flock.write_lock
+        }
+      }
+    end
+
+    def test_synchronize_unknown_mode_error
+      make_flock(true) {|flock|
+        assert_raise(ArgumentError) {
+          flock.synchronize(:UNKNOWN) {
+            flunk('not to reach')
+          }
+        }
+      }
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

data/test/test_index.rb

@@ -0,0 +1,258 @@
+#!/usr/local/bin/ruby
+
+require 'fileutils'
+require 'higgs/block'
+require 'higgs/index'
+require 'test/unit'
+
+module Higgs::Test
+  class IndexChangeNumberTest < Test::Unit::TestCase
+    include Higgs
+
+    # for ident(1)
+    CVS_ID = '$Id: test_index.rb 559 2007-09-25 15:20:20Z toki $'
+
+    def setup
+      @idx = Index.new
+    end
+
+    def test_change_number
+      assert_equal(0, @idx.change_number)
+      @idx.succ!
+      assert_equal(1, @idx.change_number)
+      @idx.succ!
+      assert_equal(2, @idx.change_number)
+      @idx.succ!
+      assert_equal(3, @idx.change_number)
+      @idx.succ!
+      assert_equal(4, @idx.change_number)
+      @idx.succ!
+      assert_equal(5, @idx.change_number)
+      @idx.succ!
+      assert_equal(6, @idx.change_number)
+      @idx.succ!
+      assert_equal(7, @idx.change_number)
+      @idx.succ!
+      assert_equal(8, @idx.change_number)
+      @idx.succ!
+      assert_equal(9, @idx.change_number)
+      @idx.succ!
+      assert_equal(10, @idx.change_number)
+    end
+  end
+
+  class IndexFreeListTest < Test::Unit::TestCase
+    include Higgs
+
+    # for ident(1)
+    CVS_ID = '$Id: test_index.rb 559 2007-09-25 15:20:20Z toki $'
+
+    def setup
+      @idx = Index.new
+    end
+
+    def test_free_single
+      assert_equal(nil, @idx.free_fetch(512))
+      @idx.free_store(0, 512)
+      assert_equal(0,   @idx.free_fetch(512))
+      assert_equal(nil, @idx.free_fetch(512))
+    end
+
+    def test_free_multi_size
+      @idx.free_store(0, 1024)
+      @idx.free_store(3584, 8192)
+      assert_equal(nil,  @idx.free_fetch(512))
+      assert_equal(0,    @idx.free_fetch(1024))
+      assert_equal(3584, @idx.free_fetch(8192))
+    end
+
+    def test_free_multi_segment
+      @idx.free_store(0,    512)
+      @idx.free_store(8192, 512)
+      @idx.free_store(9782, 512)
+      assert_equal(0,    @idx.free_fetch(512))
+      assert_equal(8192, @idx.free_fetch(512))
+      assert_equal(9782, @idx.free_fetch(512))
+      assert_equal(nil,  @idx.free_fetch(512))
+    end
+
+    def test_free_fetch_at
+      @idx.free_store(0,    512)
+      @idx.free_store(8192, 512)
+      @idx.free_store(9782, 512)
+      assert_equal(0,    @idx.free_fetch_at(0, 512))
+      assert_equal(8192, @idx.free_fetch_at(8192, 512))
+      assert_equal(9782, @idx.free_fetch_at(9782, 512))
+      assert_equal(nil,  @idx.free_fetch(512))
+    end
+  end
+
+  class IndexTest < Test::Unit::TestCase
+    include Higgs
+
+    # for ident(1)
+    CVS_ID = '$Id: test_index.rb 559 2007-09-25 15:20:20Z toki $'
+
+    def setup
+      @idx = Index.new
+    end
+
+    def test_single_entry
+      assert_equal(nil, @idx['foo'])
+      @idx['foo'] = 0
+      assert_equal(0, @idx['foo'])
+    end
+
+    def test_multi_entry
+      assert_equal(nil, @idx['foo'])
+      assert_equal(nil, @idx['bar'])
+      @idx['foo'] = 0
+      @idx['bar'] = 8192
+      assert_equal(0,    @idx['foo'])
+      assert_equal(8192, @idx['bar'])
+    end
+
+    def test_key
+      assert_equal(false, (@idx.key? 'foo'))
+      @idx['foo'] = 0
+      assert_equal(true, (@idx.key? 'foo'))
+    end
+
+    def test_keys
+      assert_equal([], @idx.keys)
+      @idx['foo'] = 0
+      assert_equal(%w[ foo ].sort, @idx.keys.sort)
+      @idx['bar'] = 512
+      assert_equal(%w[ foo bar ].sort, @idx.keys.sort)
+      @idx['baz'] = 1024
+      assert_equal(%w[ foo bar baz ].sort, @idx.keys.sort)
+    end
+
+    def test_each_key
+      assert_equal(@idx, @idx.each_key{|key| assert_fail('not to reach') })
+
+      @idx['foo'] = 0
+      expected_keys = %w[ foo ]
+      @idx.each_key do |key|
+        assert(expected_keys.delete(key), "key: #{key}")
+      end
+      assert_equal([], expected_keys)
+
+      @idx['bar'] = 512
+      expected_keys = %w[ foo bar ]
+      @idx.each_key do |key|
+        assert(expected_keys.delete(key), "key: #{key}")
+      end
+      assert_equal([], expected_keys)
+
+      @idx['baz'] = 1024
+      expected_keys = %w[ foo bar baz ]
+      @idx.each_key do |key|
+        assert(expected_keys.delete(key), "key: #{key}")
+      end
+      assert_equal([], expected_keys)
+    end
+
+    def test_delete
+      assert_equal(nil, @idx.delete('foo'))
+      @idx['foo'] = 0
+      assert_equal(0, @idx.delete('foo'))
+    end
+  end
+
+  class IndexIdentitiesTest < Test::Unit::TestCase
+    include Higgs
+
+    # for ident(1)
+    CVS_ID = '$Id: test_index.rb 559 2007-09-25 15:20:20Z toki $'
+
+    def setup
+      @idx = Index.new
+    end
+
+    def test_identity
+      @idx[:foo] = 0
+      assert_equal('foo', @idx.identity(:foo))
+    end
+
+    def test_identity_not_defined
+      assert_nil(@idx.identity(:foo))
+    end
+
+    def test_identity_dup
+      @idx[:foo] = 0
+      @idx['foo'] = 1
+      @idx[ %w[ f o o ] ] = 2
+      assert_equal('foo', @idx.identity(:foo))
+      assert_equal('foo.a', @idx.identity('foo'))
+      assert_equal('foo.b', @idx.identity(%w[ f o o ]))
+    end
+
+    def test_delete
+      @idx[:foo] = 0
+      @idx['foo'] = 1
+      @idx.delete(:foo)
+      assert_equal(nil, @idx.identity(:foo))
+      assert_equal('foo.a', @idx.identity('foo'))
+    end
+  end
+
+  class IndexLoadSaveTest < Test::Unit::TestCase
+    include Higgs
+
+    # for ident(1)
+    CVS_ID = '$Id: test_index.rb 559 2007-09-25 15:20:20Z toki $'
+
+    def setup
+      @path = 'test.idx'
+    end
+
+    def teardown
+      FileUtils.rm_f(@path)
+    end
+
+    def test_save_load
+      i = Index.new
+      i.succ!
+      i.free_store(0, 512)
+      i[:foo] = 1024
+      i.eoa = 2048
+      i.save(@path)
+
+      j = Index.new
+      j.load(@path)
+      assert_equal(1, j.change_number)
+      assert_equal(2048, j.eoa)
+      assert_equal(0, j.free_fetch(512))
+      assert_equal(1024, j[:foo])
+      assert_equal('foo', j.identity(:foo))
+    end
+
+    def test_migration
+      index_data_0_0 = {
+        :version => [ 0, 0 ],
+        :change_number => 0,
+        :eoa => 1024,
+        :free_lists => { 512 => [ 512 ] },
+        :index => { :foo => 0 }
+      }
+      File.open(@path, 'w') {|w|
+        w.binmode
+        Block.block_write(w, Index::MAGIC_SYMBOL, Marshal.dump(index_data_0_0))
+      }
+
+      i = Index.new
+      i.load(@path)
+      assert_equal(0, i.change_number)
+      assert_equal(1024, i.eoa)
+      assert_equal(512, i.free_fetch(512))
+      assert_equal(0, i[:foo])
+      assert_equal('foo', i.identity(:foo))
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End: