rims 0.2.1

data/test/test_error.rb

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+
+require 'logger'
+require 'pp' if $DEBUG
+require 'rims'
+require 'test/unit'
+
+module RIMS::Test
+  class TestError < Test::Unit::TestCase
+    class FooError < StandardError
+    end
+
+    class BarError < StandardError
+    end
+
+    def setup
+      @logger = Logger.new(STDOUT)
+      @logger.level = ($DEBUG) ? Logger::DEBUG : Logger::FATAL
+      @flow_list = []
+    end
+
+    def teardown
+      pp @flow_list if $DEBUG
+    end
+
+    def test_suppress_2nd_error_at_resource_closing_no_error
+      begin
+        @flow_list << :main
+      ensure
+        RIMS::Error.suppress_2nd_error_at_resource_closing{ @flow_list << :close }
+      end
+      assert_equal([ :main, :close ], @flow_list)
+
+      begin
+        @flow_list << :main
+      ensure
+        RIMS::Error.suppress_2nd_error_at_resource_closing(logger: @logger) { @flow_list << :close }
+      end
+      assert_equal([ :main, :close, :main, :close ], @flow_list)
+    end
+
+    def test_suppress_2nd_error_at_resource_closing_raise_1st_error
+      assert_raise(FooError) {
+        begin
+          raise FooError
+          @flow_list << :main
+        ensure
+          RIMS::Error.suppress_2nd_error_at_resource_closing{ @flow_list << :close }
+        end
+      }
+      assert_equal([ :close ], @flow_list)
+
+      assert_raise(FooError) {
+        begin
+          raise FooError
+          @flow_list << :main
+        ensure
+          RIMS::Error.suppress_2nd_error_at_resource_closing(logger: @logger) { @flow_list << :close }
+        end
+      }
+      assert_equal([ :close, :close ], @flow_list)
+    end
+
+    def test_suppress_2nd_error_at_resource_closing_suppress_2nd_error
+      assert_raise(FooError) {
+        begin
+          raise FooError
+          @flow_list << :main
+        ensure
+          RIMS::Error.suppress_2nd_error_at_resource_closing{
+            raise BarError
+            @flow_list << :close
+          }
+        end
+      }
+      assert_equal([], @flow_list)
+
+      assert_raise(FooError) {
+        begin
+          raise FooError
+          @flow_list << :main
+        ensure
+          RIMS::Error.suppress_2nd_error_at_resource_closing(logger: @logger) {
+            raise BarError
+            @flow_list << :close
+          }
+        end
+      }
+      assert_equal([], @flow_list)
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

data/test/test_gdbm_kvs.rb

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+
+require 'gdbm'
+require 'rims'
+require 'test/unit'
+
+module RIMS::Test
+  class GDBM_KeyValueStoreTest < Test::Unit::TestCase
+    include KeyValueStoreTestUtility
+
+    def open_database
+      GDBM.new(@name)
+    end
+
+    def make_key_value_store
+      RIMS::GDBM_KeyValueStore.new(@db, @name)
+    end
+  end
+
+  class GDBM_KeyValueStoreOpenCloseTest < Test::Unit::TestCase
+    include KeyValueStoreOpenCloseTestUtility
+
+    def get_kvs_name
+      'gdbm'
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

data/test/test_hash_kvs.rb

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+
+require 'pp' if $DEBUG
+require 'rims'
+require 'test/unit'
+
+module RIMS::Test
+  class Hash_KeyValueStoreTest < Test::Unit::TestCase
+    def setup
+      @db = {}
+      @kvs = RIMS::Hash_KeyValueStore.new(@db)
+    end
+
+    def teardown
+      pp @db if $DEBUG
+    end
+
+    def test_store_fetch
+      assert_nil(@db['foo'])
+      assert_nil(@kvs['foo'])
+
+      assert_equal('apple', (@kvs['foo'] = 'apple'))
+      assert_equal({ 'foo' => 'apple' }, @db)
+
+      assert_equal('apple', @db['foo'])
+      assert_equal('apple', @kvs['foo'])
+    end
+
+    def test_delete
+      assert_nil(@kvs.delete('foo'))
+
+      @kvs['foo'] = 'apple'
+      assert_equal({ 'foo' => 'apple' }, @db)
+      assert_equal('apple', @kvs.delete('foo'))
+      assert_equal({}, @db)
+
+      assert_nil(@db['foo'])
+      assert_nil(@kvs['foo'])
+    end
+
+    def test_key?
+      assert_equal(false, (@db.key? 'foo'))
+      assert_equal(false, (@kvs.key? 'foo'))
+
+      @kvs['foo'] = 'apple'
+      assert_equal({ 'foo' => 'apple' }, @db)
+      assert_equal(true, (@db.key? 'foo'))
+      assert_equal(true, (@kvs.key? 'foo'))
+
+      @kvs.delete('foo')
+      assert_equal({}, @db)
+      assert_equal(false, (@db.key? 'foo'))
+      assert_equal(false, (@kvs.key? 'foo'))
+    end
+
+    def test_each_key
+      assert_equal(%w[], @db.each_key.to_a)
+      assert_equal(%w[], @kvs.each_key.to_a)
+
+      @kvs['foo'] = 'apple'
+      assert_equal({ 'foo' => 'apple' }, @db)
+      assert_equal(%w[ foo ], @db.each_key.to_a)
+      assert_equal(%w[ foo ], @kvs.each_key.to_a)
+      assert_equal(%w[ apple ], @kvs.each_value.to_a)
+      assert_equal([ %w[ foo apple ] ], @kvs.each_pair.to_a)
+
+      @kvs['bar'] = 'banana'
+      assert_equal({ 'foo' => 'apple', 'bar' => 'banana' }, @db)
+      assert_equal(%w[ foo bar ], @db.each_key.to_a)
+      assert_equal(%w[ foo bar ], @kvs.each_key.to_a)
+      assert_equal(%w[ apple banana ], @kvs.each_value.to_a)
+      assert_equal([ %w[ foo apple ], %w[ bar banana ] ], @kvs.each_pair.to_a)
+
+      @kvs['baz'] = 'orange'
+      assert_equal({ 'foo' => 'apple', 'bar' => 'banana', 'baz' => 'orange' }, @db)
+      assert_equal(%w[ foo bar baz ], @db.each_key.to_a)
+      assert_equal(%w[ foo bar baz ], @kvs.each_key.to_a)
+      assert_equal(%w[ apple banana orange ], @kvs.each_value.to_a)
+      assert_equal([ %w[ foo apple ], %w[ bar banana ], %w[ baz orange ] ], @kvs.each_pair.to_a)
+
+      @kvs.delete('bar')
+      assert_equal({ 'foo' => 'apple', 'baz' => 'orange' }, @db)
+      assert_equal(%w[ foo baz ], @db.each_key.to_a)
+      assert_equal(%w[ foo baz ], @kvs.each_key.to_a)
+      assert_equal(%w[ apple orange ], @kvs.each_value.to_a)
+      assert_equal([ %w[ foo apple ], %w[ baz orange ] ], @kvs.each_pair.to_a)
+    end
+
+    def test_sync
+      @kvs.sync
+    end
+
+    def test_close
+      @kvs.close
+
+      # nil exception
+      assert_raise(NoMethodError) { @kvs['foo'] }
+      assert_raise(NoMethodError) { @kvs['foo'] = 'apple' }
+      assert_raise(NoMethodError) { @kvs.delete('foo') }
+      assert_raise(NoMethodError) { @kvs.key? 'foo' }
+      assert_raise(NoMethodError) { @kvs.each_key.to_a }
+      assert_raise(NoMethodError) { @kvs.each_value.to_a }
+      assert_raise(NoMethodError) { @kvs.each_pair.to_a }
+      assert_equal({}, @db)
+    end
+
+    def test_destroy
+      @kvs.destroy
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

data/test/test_lock.rb

@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+
+require 'rims'
+require 'test/unit'
+
+Thread.abort_on_exception = true if $DEBUG
+
+module RIMS::Test
+  class ReadWriteLockTest < Test::Unit::TestCase
+    def setup
+      @lock = RIMS::ReadWriteLock.new
+    end
+
+    def test_read_lock
+      count = 0
+      @lock.read_synchronize{ count += 1 }
+      assert_equal(1, count)
+    end
+
+    def test_read_lock_simultaneous
+      count = 0
+      @lock.read_synchronize{
+        @lock.read_synchronize{
+          count += 1
+        }
+      }
+      assert_equal(1, count)
+    end
+
+    def test_write_lock
+      count = 0
+      @lock.write_synchronize{ count += 1 }
+      assert_equal(1, count)
+    end
+
+    def test_read_lock_timeout
+      assert_raise(RIMS::ReadLockTimeoutError) {
+        @lock.write_synchronize{
+          @lock.read_synchronize(0) {}
+        }
+      }
+    end
+
+    def test_write_lock_timeout
+      assert_raise(RIMS::WriteLockTimeoutError) {
+        @lock.write_synchronize{
+          @lock.write_synchronize(0) {}
+        }
+      }
+    end
+
+    def calculate_threa_work_seconds
+      t0 = Time.now
+      1000.times{|i| i.succ }
+      t1 = Time.now
+      wait_seconds = t1 - t0
+      p format('%.9f', wait_seconds) if $DEBUG
+
+      wait_seconds
+    end
+    private :calculate_threa_work_seconds
+
+    def test_read_write_lock_multithread
+      lock_wait_seconds = calculate_threa_work_seconds
+
+      count = 0
+      read_thread_num = 10
+      write_thread_num = 5
+      write_loop_num = 100
+
+      mutex = Thread::Mutex.new
+      end_of_read = false
+
+      read_thread_list = []
+      read_thread_num.times do |i|
+        read_thread_list << Thread.new(i) {|th_id|
+          until (mutex.synchronize{ end_of_read })
+            @lock.read_synchronize{
+              sleep(lock_wait_seconds)
+              assert(count >= 0, "read thread #{th_id}")
+            }
+          end
+        }
+      end
+
+      sleep(lock_wait_seconds)
+
+      write_thread_list = []
+      write_thread_num.times do |i|
+        write_thread_list << Thread.new(i) {|th_id|
+          write_loop_num.times do
+            @lock.write_synchronize{
+              tmp_count = count
+              count = -1
+              sleep(lock_wait_seconds)
+              count = tmp_count + 1
+            }
+          end
+        }
+      end
+
+      for t in write_thread_list
+        t.join
+      end
+
+      mutex.synchronize{ end_of_read = true }
+      for t in read_thread_list
+        t.join
+      end
+
+      assert_equal(write_loop_num * write_thread_num, count)
+    end
+
+    def test_write_lock_timeout_detach
+      logger = Logger.new(STDOUT)
+      logger.level = ($DEBUG) ? Logger::DEBUG : Logger::FATAL
+      wait_seconds = calculate_threa_work_seconds
+
+      t_list = []
+      assert_nil(RIMS::ReadWriteLock.write_lock_timeout_detach(wait_seconds, wait_seconds * 2, logger: logger ) {|timeout_seconds|
+                   @lock.write_synchronize(timeout_seconds) { t_list << timeout_seconds }
+                 })
+      assert_equal([ wait_seconds ], t_list)
+
+      t_list = []
+      detached_thread = nil
+      @lock.write_synchronize{
+        detached_thread = RIMS::ReadWriteLock.write_lock_timeout_detach(wait_seconds, wait_seconds * 2, logger: logger ) {|timeout_seconds|
+          @lock.write_synchronize(timeout_seconds) { t_list << timeout_seconds }
+        }
+        assert_instance_of(Thread, detached_thread)
+        10.times do
+          sleep(wait_seconds)
+        end
+      }
+
+      assert_nil(detached_thread.value)
+      assert_equal([ wait_seconds * 2 ], t_list)
+
+      detached_thread = nil
+      @lock.write_synchronize{
+        detached_thread = RIMS::ReadWriteLock.write_lock_timeout_detach(wait_seconds, wait_seconds * 2, logger: logger ) {|timeout_seconds|
+          @lock.write_synchronize(timeout_seconds) { raise 'test' }
+        }
+        assert_instance_of(Thread, detached_thread)
+        10.times do
+          sleep(wait_seconds)
+        end
+      }
+
+      assert(error = detached_thread.value)
+      assert_equal('test', error.message)
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:
+

data/test/test_mail_store.rb

@@ -0,0 +1,750 @@
+# -*- coding: utf-8 -*-
+
+require 'logger'
+require 'pp' if $DEBUG
+require 'rims'
+require 'test/unit'
+require 'time'
+
+module RIMS::Test
+  class MailStoreTest < Test::Unit::TestCase
+    include AssertUtility
+
+    def setup
+      @kvs = Hash.new{|h, k| h[k] = Hash.new }
+      @kvs_open = proc{|name| RIMS::Hash_KeyValueStore.new(@kvs[name]) }
+      @mail_store = RIMS::MailStore.new(RIMS::DB::Meta.new(@kvs_open.call('meta')),
+                                        RIMS::DB::Message.new(@kvs_open.call('msg'))) {|mbox_id|
+        RIMS::DB::Mailbox.new(@kvs_open.call("mbox_#{mbox_id}"))
+      }
+    end
+
+    def teardown
+      @mail_store.close if @mail_store
+      pp @kvs if $DEBUG
+    end
+
+    def test_mbox
+      assert_equal(0, @mail_store.cnum)
+      assert_equal(1, @mail_store.uidvalidity)
+      assert_equal([], @mail_store.each_mbox_id.to_a)
+
+      assert_equal(1, @mail_store.add_mbox('INBOX'))
+      assert_equal(1, @mail_store.cnum)
+      assert_equal(2, @mail_store.uidvalidity)
+      assert_strenc_equal('utf-8', 'INBOX', @mail_store.mbox_name(1))
+      assert_equal(1, @mail_store.mbox_id('INBOX'))
+      assert_equal([ 1 ], @mail_store.each_mbox_id.to_a)
+
+      assert_equal('INBOX', @mail_store.rename_mbox(1, 'foo'))
+      assert_equal(2, @mail_store.cnum)
+      assert_equal(2, @mail_store.uidvalidity)
+      assert_strenc_equal('utf-8', 'foo', @mail_store.mbox_name(1))
+      assert_equal(1, @mail_store.mbox_id('foo'))
+      assert_nil(@mail_store.mbox_id('INBOX'))
+      assert_equal([ 1 ], @mail_store.each_mbox_id.to_a)
+
+      assert_equal('foo', @mail_store.del_mbox(1))
+      assert_equal(3, @mail_store.cnum)
+      assert_equal(2, @mail_store.uidvalidity)
+      assert_nil(@mail_store.mbox_name(1))
+      assert_nil(@mail_store.mbox_id('foo'))
+      assert_equal([], @mail_store.each_mbox_id.to_a)
+
+      assert_equal(2, @mail_store.add_mbox('INBOX'))
+      assert_equal(4, @mail_store.cnum)
+      assert_equal(3, @mail_store.uidvalidity)
+      assert_strenc_equal('utf-8', 'INBOX', @mail_store.mbox_name(2))
+      assert_equal(2, @mail_store.mbox_id('INBOX'))
+      assert_equal([ 2 ], @mail_store.each_mbox_id.to_a)
+    end
+
+    def test_msg
+      cnum = @mail_store.cnum
+      mbox_id = @mail_store.add_mbox('INBOX')
+      assert_equal(0, @mail_store.mbox_msg_num(mbox_id))
+      assert_equal([], @mail_store.each_msg_uid(mbox_id).to_a)
+      assert(! (@mail_store.msg_exist? mbox_id, 1))
+      assert(@mail_store.cnum > cnum); cnum = @mail_store.cnum
+      uid = @mail_store.add_msg(mbox_id, 'foo', Time.parse('1975-11-19 12:34:56'))
+      assert(@mail_store.cnum > cnum); cnum = @mail_store.cnum
+      assert_equal(1, @mail_store.mbox_msg_num(mbox_id))
+      assert((@mail_store.msg_exist? mbox_id, 1))
+      assert_equal([ uid ], @mail_store.each_msg_uid(mbox_id).to_a)
+
+      assert_equal('foo', @mail_store.msg_text(mbox_id, uid))
+      assert_equal(Time.parse('1975-11-19 12:34:56'), @mail_store.msg_date(mbox_id, uid))
+
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'seen'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'answered'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'flagged'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'deleted'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'draft'))
+      assert_equal(1, @mail_store.mbox_flag_num(mbox_id, 'recent'))
+
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'seen'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'answered'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'flagged'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'deleted'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'draft'))
+      assert_equal(true, @mail_store.msg_flag(mbox_id, uid, 'recent'))
+
+      copy_mbox_id = @mail_store.add_mbox('copy_test')
+      assert_equal(0, @mail_store.mbox_msg_num(copy_mbox_id))
+      assert_equal([], @mail_store.each_msg_uid(copy_mbox_id).to_a)
+      assert(@mail_store.cnum > cnum); cnum = @mail_store.cnum
+      copy_uid = @mail_store.copy_msg(uid, mbox_id, copy_mbox_id)
+      assert_equal(1, copy_uid)
+      assert(@mail_store.cnum > cnum); cnum = @mail_store.cnum
+      assert_equal(1, @mail_store.mbox_msg_num(copy_mbox_id))
+      assert_equal([ uid ], @mail_store.each_msg_uid(copy_mbox_id).to_a)
+
+      assert_equal('foo', @mail_store.msg_text(copy_mbox_id, uid))
+      assert_equal(Time.parse('1975-11-19 12:34:56'), @mail_store.msg_date(copy_mbox_id, uid))
+
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'seen'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'answered'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'flagged'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'deleted'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'draft'))
+      assert_equal(1, @mail_store.mbox_flag_num(copy_mbox_id, 'recent'))
+
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'seen'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'answered'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'flagged'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'deleted'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'draft'))
+      assert_equal(true, @mail_store.msg_flag(copy_mbox_id, uid, 'recent'))
+
+      # duplicated message copy
+      copy2_uid = @mail_store.copy_msg(uid, mbox_id, copy_mbox_id)
+      assert_equal(2, copy2_uid)
+      assert(@mail_store.cnum > cnum); cnum = @mail_store.cnum
+      assert_equal(2, @mail_store.mbox_msg_num(copy_mbox_id))
+      assert_equal([ uid, uid + 1 ], @mail_store.each_msg_uid(copy_mbox_id).to_a)
+
+      assert_equal('foo', @mail_store.msg_text(copy_mbox_id, uid))
+      assert_equal(Time.parse('1975-11-19 12:34:56'), @mail_store.msg_date(copy_mbox_id, uid))
+
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'seen'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'answered'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'flagged'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'deleted'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'draft'))
+      assert_equal(2, @mail_store.mbox_flag_num(copy_mbox_id, 'recent'))
+
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'seen'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'answered'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'flagged'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'deleted'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'draft'))
+      assert_equal(true, @mail_store.msg_flag(copy_mbox_id, uid, 'recent'))
+
+      @mail_store.set_msg_flag(mbox_id, uid, 'seen', true)
+      assert(@mail_store.cnum > cnum); cnum = @mail_store.cnum
+
+      assert_equal(1, @mail_store.mbox_flag_num(mbox_id, 'seen'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'answered'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'flagged'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'deleted'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'draft'))
+      assert_equal(1, @mail_store.mbox_flag_num(mbox_id, 'recent'))
+
+      assert_equal(true, @mail_store.msg_flag(mbox_id, uid, 'seen'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'answered'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'flagged'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'deleted'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'draft'))
+      assert_equal(true, @mail_store.msg_flag(mbox_id, uid, 'recent'))
+
+      assert_equal(2, @mail_store.mbox_flag_num(copy_mbox_id, 'seen'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'answered'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'flagged'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'deleted'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'draft'))
+      assert_equal(2, @mail_store.mbox_flag_num(copy_mbox_id, 'recent'))
+
+      assert_equal(true, @mail_store.msg_flag(copy_mbox_id, uid, 'seen'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'answered'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'flagged'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'deleted'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'draft'))
+      assert_equal(true, @mail_store.msg_flag(copy_mbox_id, uid, 'recent'))
+
+      # duplicated flag settings
+      @mail_store.set_msg_flag(mbox_id, uid, 'seen', true)
+      assert(@mail_store.cnum > cnum); cnum = @mail_store.cnum
+
+      assert_equal(1, @mail_store.mbox_flag_num(mbox_id, 'seen'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'answered'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'flagged'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'deleted'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'draft'))
+      assert_equal(1, @mail_store.mbox_flag_num(mbox_id, 'recent'))
+
+      assert_equal(true, @mail_store.msg_flag(mbox_id, uid, 'seen'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'answered'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'flagged'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'deleted'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'draft'))
+      assert_equal(true, @mail_store.msg_flag(mbox_id, uid, 'recent'))
+
+      assert_equal(2, @mail_store.mbox_flag_num(copy_mbox_id, 'seen'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'answered'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'flagged'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'deleted'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'draft'))
+      assert_equal(2, @mail_store.mbox_flag_num(copy_mbox_id, 'recent'))
+
+      assert_equal(true, @mail_store.msg_flag(copy_mbox_id, uid, 'seen'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'answered'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'flagged'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'deleted'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'draft'))
+      assert_equal(true, @mail_store.msg_flag(copy_mbox_id, uid, 'recent'))
+
+      @mail_store.set_msg_flag(mbox_id, uid, 'recent', false)
+      assert(@mail_store.cnum > cnum); cnum = @mail_store.cnum
+
+      assert_equal(1, @mail_store.mbox_flag_num(mbox_id, 'seen'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'answered'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'flagged'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'deleted'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'draft'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'recent'))
+
+      assert_equal(true, @mail_store.msg_flag(mbox_id, uid, 'seen'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'answered'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'flagged'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'deleted'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'draft'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'recent'))
+
+      assert_equal(2, @mail_store.mbox_flag_num(copy_mbox_id, 'seen'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'answered'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'flagged'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'deleted'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'draft'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'recent'))
+
+      assert_equal(true, @mail_store.msg_flag(copy_mbox_id, uid, 'seen'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'answered'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'flagged'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'deleted'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'draft'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'recent'))
+
+      # duplicated
+      @mail_store.set_msg_flag(mbox_id, uid, 'recent', false)
+      assert(@mail_store.cnum > cnum); cnum = @mail_store.cnum
+
+      assert_equal(1, @mail_store.mbox_flag_num(mbox_id, 'seen'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'answered'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'flagged'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'deleted'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'draft'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'recent'))
+
+      assert_equal(true, @mail_store.msg_flag(mbox_id, uid, 'seen'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'answered'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'flagged'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'deleted'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'draft'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'recent'))
+
+      assert_equal(2, @mail_store.mbox_flag_num(copy_mbox_id, 'seen'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'answered'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'flagged'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'deleted'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'draft'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'recent'))
+
+      assert_equal(true, @mail_store.msg_flag(copy_mbox_id, uid, 'seen'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'answered'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'flagged'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'deleted'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'draft'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'recent'))
+
+      @mail_store.set_msg_flag(mbox_id, uid, 'deleted', true)
+      assert(@mail_store.cnum > cnum); cnum = @mail_store.cnum
+
+      assert_equal(1, @mail_store.mbox_flag_num(mbox_id, 'seen'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'answered'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'flagged'))
+      assert_equal(1, @mail_store.mbox_flag_num(mbox_id, 'deleted'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'draft'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'recent'))
+
+      assert_equal(true, @mail_store.msg_flag(mbox_id, uid, 'seen'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'answered'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'flagged'))
+      assert_equal(true, @mail_store.msg_flag(mbox_id, uid, 'deleted'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'draft'))
+      assert_equal(false, @mail_store.msg_flag(mbox_id, uid, 'recent'))
+
+      assert_equal(2, @mail_store.mbox_flag_num(copy_mbox_id, 'seen'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'answered'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'flagged'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'deleted'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'draft'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'recent'))
+
+      assert_equal(true, @mail_store.msg_flag(copy_mbox_id, uid, 'seen'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'answered'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'flagged'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'deleted'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'draft'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'recent'))
+
+      @mail_store.expunge_mbox(mbox_id)
+      assert(@mail_store.cnum > cnum); cnum = @mail_store.cnum
+      assert_equal(0, @mail_store.mbox_msg_num(mbox_id))
+      assert_equal([], @mail_store.each_msg_uid(mbox_id).to_a)
+
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'seen'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'answered'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'flagged'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'deleted'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'draft'))
+      assert_equal(0, @mail_store.mbox_flag_num(mbox_id, 'recent'))
+
+      assert_equal(2, @mail_store.mbox_msg_num(copy_mbox_id))
+      assert_equal([ uid, uid + 1 ], @mail_store.each_msg_uid(copy_mbox_id).to_a)
+
+      assert_equal(2, @mail_store.mbox_flag_num(copy_mbox_id, 'seen'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'answered'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'flagged'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'deleted'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'draft'))
+      assert_equal(0, @mail_store.mbox_flag_num(copy_mbox_id, 'recent'))
+
+      assert_equal(true, @mail_store.msg_flag(copy_mbox_id, uid, 'seen'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'answered'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'flagged'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'deleted'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'draft'))
+      assert_equal(false, @mail_store.msg_flag(copy_mbox_id, uid, 'recent'))
+    end
+
+    def test_mail_folder
+      mbox_id = @mail_store.add_mbox('INBOX')
+      folder = @mail_store.select_mbox(mbox_id)
+      assert_equal(mbox_id, folder.mbox_id)
+      assert_equal(false, folder.read_only)
+      assert_equal(true, folder.updated?)
+
+      folder.reload
+      assert_equal(false, folder.updated?)
+      assert_equal([], folder.each_msg.to_a)
+
+      @mail_store.add_msg(mbox_id, 'foo')
+      assert_equal(true, folder.updated?)
+      folder.reload
+      assert_equal(false, folder.updated?)
+      assert_equal(1, folder[0].num)
+      assert_equal(1, folder[0].uid)
+      assert_equal([ [ 1, 1 ] ], folder.each_msg.map{|i| i.to_a })
+    end
+
+    def each_msg_src
+      return enum_for(:each_msg_src) unless block_given?
+      s = 'a'
+      loop do
+        yield(s)
+        s.succ!
+      end
+    end
+    private :each_msg_src
+
+    def test_mail_folder_parse_msg_set
+      mbox_id = @mail_store.add_mbox('INBOX')
+
+      msg_src = each_msg_src
+      100.times do
+        @mail_store.add_msg(mbox_id, msg_src.next)
+      end
+      @mail_store.each_msg_uid(mbox_id) do |id|
+        if (id % 2 == 0) then
+          @mail_store.set_msg_flag(mbox_id, id, 'deleted', true)
+        end
+      end
+      @mail_store.expunge_mbox(mbox_id)
+
+      folder = @mail_store.select_mbox(mbox_id).reload
+
+      assert_equal([ 1 ].to_set, folder.parse_msg_set('1'))
+      assert_equal([ 1 ].to_set, folder.parse_msg_set('1', uid: false))
+      assert_equal([ 1 ].to_set, folder.parse_msg_set('1', uid: true))
+
+      assert_equal([ 2 ].to_set, folder.parse_msg_set('2'))
+      assert_equal([ 2 ].to_set, folder.parse_msg_set('2', uid: false))
+      assert_equal([ 2 ].to_set, folder.parse_msg_set('2', uid: true))
+
+      assert_equal([ 50 ].to_set, folder.parse_msg_set('*'))
+      assert_equal([ 50 ].to_set, folder.parse_msg_set('*', uid: false))
+      assert_equal([ 99 ].to_set, folder.parse_msg_set('*', uid: true))
+
+      assert_equal((1..50).to_set, folder.parse_msg_set('1:*'))
+      assert_equal((1..50).to_set, folder.parse_msg_set('1:*', uid: false))
+      assert_equal((1..99).to_set, folder.parse_msg_set('1:*', uid: true))
+
+      assert_raise(RIMS::MessageSetSyntaxError) {
+        folder.parse_msg_set('detarame')
+      }
+    end
+
+    def test_mail_folder_parse_msg_set_empty
+      mbox_id = @mail_store.add_mbox('INBOX')
+      assert_equal([], @mail_store.each_msg_uid(mbox_id).to_a)
+      folder = @mail_store.select_mbox(mbox_id).reload
+
+      assert_equal([ 1 ].to_set, folder.parse_msg_set('1'))
+      assert_equal([ 1 ].to_set, folder.parse_msg_set('1', uid: false))
+      assert_equal([ 1 ].to_set, folder.parse_msg_set('1', uid: true))
+
+      assert_equal([ 0 ].to_set, folder.parse_msg_set('*'))
+      assert_equal([ 0 ].to_set, folder.parse_msg_set('*', uid: false))
+      assert_equal([ 0 ].to_set, folder.parse_msg_set('*', uid: true))
+
+      assert_equal([].to_set, folder.parse_msg_set('1:*'))
+      assert_equal([].to_set, folder.parse_msg_set('1:*', uid: false))
+      assert_equal([].to_set, folder.parse_msg_set('1:*', uid: true))
+    end
+
+    def test_mail_folder_expunge_mbox
+      mbox_id = @mail_store.add_mbox('INBOX')
+      @mail_store.add_msg(mbox_id, 'a') # 1 deleted
+      @mail_store.add_msg(mbox_id, 'b') # 2 deleted
+      @mail_store.add_msg(mbox_id, 'c') # 3
+      @mail_store.add_msg(mbox_id, 'd') # 4
+      @mail_store.add_msg(mbox_id, 'e') # 5
+      @mail_store.add_msg(mbox_id, 'f') # 6 deleted
+      @mail_store.add_msg(mbox_id, 'g') # 7
+      @mail_store.add_msg(mbox_id, 'h') # 8 deleted
+
+      folder = @mail_store.select_mbox(mbox_id).reload
+      assert_equal(8, folder.each_msg.count)
+
+      client_msg_list = folder.each_msg.to_a
+      @mail_store.set_msg_flag(mbox_id, client_msg_list[0].uid, 'deleted', true)
+      @mail_store.set_msg_flag(mbox_id, client_msg_list[7].uid, 'deleted', true)
+      @mail_store.set_msg_flag(mbox_id, client_msg_list[1].uid, 'deleted', true)
+      @mail_store.set_msg_flag(mbox_id, client_msg_list[5].uid, 'deleted', true)
+
+      folder.expunge_mbox do |msg_num|
+        client_msg_list.delete_at(msg_num - 1)
+      end
+      folder.reload
+
+      assert_equal(folder.each_msg.map(&:uid), client_msg_list.map(&:uid))
+    end
+
+    def test_close_open
+      mbox_id1 = @mail_store.add_mbox('INBOX')
+      msg_uid1 = @mail_store.add_msg(mbox_id1, 'foo', Time.local(2014, 5, 6, 12, 34, 56))
+      msg_uid2 = @mail_store.add_msg(mbox_id1, 'bar', Time.local(2014, 5, 6, 12, 34, 57))
+      msg_uid3 = @mail_store.add_msg(mbox_id1, 'baz', Time.local(2014, 5, 6, 12, 34, 58))
+      mbox_id2 = @mail_store.add_mbox('foo')
+      mbox_id3 = @mail_store.add_mbox('bar')
+
+      assert_equal(mbox_id3 + 1, @mail_store.uidvalidity)
+      assert_equal([ mbox_id1, mbox_id2, mbox_id3 ], @mail_store.each_mbox_id.to_a)
+      assert_equal('INBOX', @mail_store.mbox_name(mbox_id1))
+      assert_equal('foo', @mail_store.mbox_name(mbox_id2))
+      assert_equal('bar', @mail_store.mbox_name(mbox_id3))
+      assert_equal(mbox_id1, @mail_store.mbox_id('INBOX'))
+      assert_equal(mbox_id2, @mail_store.mbox_id('foo'))
+      assert_equal(mbox_id3, @mail_store.mbox_id('bar'))
+      assert_equal(mbox_id3 + 1, @mail_store.uid(mbox_id1))
+      assert_equal(1, @mail_store.uid(mbox_id2))
+      assert_equal(1, @mail_store.uid(mbox_id3))
+      assert_equal(3, @mail_store.mbox_msg_num(mbox_id1))
+      assert_equal(0, @mail_store.mbox_msg_num(mbox_id2))
+      assert_equal(0, @mail_store.mbox_msg_num(mbox_id2))
+
+      assert_equal([ msg_uid1, msg_uid2, msg_uid3 ], @mail_store.each_msg_uid(mbox_id1).to_a)
+      assert_equal('foo', @mail_store.msg_text(mbox_id1, msg_uid1))
+      assert_equal('bar', @mail_store.msg_text(mbox_id1, msg_uid2))
+      assert_equal('baz', @mail_store.msg_text(mbox_id1, msg_uid3))
+      assert_equal(Time.local(2014, 5, 6, 12, 34, 56), @mail_store.msg_date(mbox_id1, msg_uid1))
+      assert_equal(Time.local(2014, 5, 6, 12, 34, 57), @mail_store.msg_date(mbox_id1, msg_uid2))
+      assert_equal(Time.local(2014, 5, 6, 12, 34, 58), @mail_store.msg_date(mbox_id1, msg_uid3))
+
+      @mail_store.close
+      @mail_store = RIMS::MailStore.new(RIMS::DB::Meta.new(@kvs_open.call('meta')),
+                                        RIMS::DB::Message.new(@kvs_open.call('msg'))) {|mbox_id|
+        RIMS::DB::Mailbox.new(@kvs_open.call("mbox_#{mbox_id}"))
+      }
+
+      assert_equal(mbox_id3 + 1, @mail_store.uidvalidity)
+      assert_equal([ mbox_id1, mbox_id2, mbox_id3 ], @mail_store.each_mbox_id.to_a)
+      assert_equal('INBOX', @mail_store.mbox_name(mbox_id1))
+      assert_equal('foo', @mail_store.mbox_name(mbox_id2))
+      assert_equal('bar', @mail_store.mbox_name(mbox_id3))
+      assert_equal(mbox_id1, @mail_store.mbox_id('INBOX'))
+      assert_equal(mbox_id2, @mail_store.mbox_id('foo'))
+      assert_equal(mbox_id3, @mail_store.mbox_id('bar'))
+      assert_equal(mbox_id3 + 1, @mail_store.uid(mbox_id1))
+      assert_equal(1, @mail_store.uid(mbox_id2))
+      assert_equal(1, @mail_store.uid(mbox_id3))
+      assert_equal(3, @mail_store.mbox_msg_num(mbox_id1))
+      assert_equal(0, @mail_store.mbox_msg_num(mbox_id2))
+      assert_equal(0, @mail_store.mbox_msg_num(mbox_id2))
+
+      assert_equal([ msg_uid1, msg_uid2, msg_uid3 ], @mail_store.each_msg_uid(mbox_id1).to_a)
+      assert_equal('foo', @mail_store.msg_text(mbox_id1, msg_uid1))
+      assert_equal('bar', @mail_store.msg_text(mbox_id1, msg_uid2))
+      assert_equal('baz', @mail_store.msg_text(mbox_id1, msg_uid3))
+      assert_equal(Time.local(2014, 5, 6, 12, 34, 56), @mail_store.msg_date(mbox_id1, msg_uid1))
+      assert_equal(Time.local(2014, 5, 6, 12, 34, 57), @mail_store.msg_date(mbox_id1, msg_uid2))
+      assert_equal(Time.local(2014, 5, 6, 12, 34, 58), @mail_store.msg_date(mbox_id1, msg_uid3))
+    end
+  end
+
+  class MailFolderClassMethodTest < Test::Unit::TestCase
+    def test_parse_msg_seq
+      assert_equal(1..1, RIMS::MailFolder.parse_msg_seq('1', 99))
+      assert_equal(99..99, RIMS::MailFolder.parse_msg_seq('*', 99))
+      assert_equal(1..10, RIMS::MailFolder.parse_msg_seq('1:10', 99))
+      assert_equal(1..99, RIMS::MailFolder.parse_msg_seq('1:*', 99))
+      assert_equal(99..99, RIMS::MailFolder.parse_msg_seq('*:*', 99))
+      assert_raise(RIMS::MessageSetSyntaxError) {
+        RIMS::MailFolder.parse_msg_seq('detarame', 99)
+      }
+    end
+
+    def test_parse_msg_set
+      assert_equal([ 1 ].to_set, RIMS::MailFolder.parse_msg_set('1', 99))
+      assert_equal([ 99 ].to_set, RIMS::MailFolder.parse_msg_set('*', 99))
+      assert_equal((1..10).to_set, RIMS::MailFolder.parse_msg_set('1:10', 99))
+      assert_equal((1..99).to_set, RIMS::MailFolder.parse_msg_set('1:*', 99))
+      assert_equal((99..99).to_set, RIMS::MailFolder.parse_msg_set('*:*', 99))
+
+      assert_equal([ 1, 5, 7, 99 ].to_set, RIMS::MailFolder.parse_msg_set('1,5,7,*', 99))
+      assert_equal([ 1, 2, 3, 11, 97, 98, 99 ].to_set, RIMS::MailFolder.parse_msg_set('1:3,11,97:*', 99))
+      assert_equal((1..99).to_set, RIMS::MailFolder.parse_msg_set('1:70,30:*', 99))
+
+      assert_raise(RIMS::MessageSetSyntaxError) {
+        RIMS::MailFolder.parse_msg_set('detarame', 99)
+      }
+      assert_raise(RIMS::MessageSetSyntaxError) {
+        RIMS::MailFolder.parse_msg_set('1,2,X', 99)
+      }
+    end
+  end
+
+  class MailStoreRecoveryTest < Test::Unit::TestCase
+    def setup
+      @logger = Logger.new(STDOUT)
+      @logger.level = ($DEBUG) ? Logger::DEBUG : Logger::FATAL
+
+      @kvs = Hash.new{|h, k| h[k] = Hash.new }
+      @kvs_open = proc{|name| RIMS::Hash_KeyValueStore.new(@kvs[name]) }
+      @mbox_db_factory = proc{|mbox_id| RIMS::DB::Mailbox.new(@kvs_open.call("mbox_#{mbox_id}")) }
+    end
+
+    def teardown
+      pp @kvs if $DEBUG
+    end
+
+    def make_mail_store
+      RIMS::MailStore.new(RIMS::DB::Meta.new(@kvs_open.call('meta')),
+                          RIMS::DB::Message.new(@kvs_open.call('msg'))) {|mbox_id|
+        RIMS::DB::Mailbox.new(@kvs_open.call("mbox_#{mbox_id}"))
+      }
+    end
+    private :make_mail_store
+
+    def test_no_recovery
+      mail_store = make_mail_store
+      assert_equal(false, mail_store.abort_transaction?)
+      mail_store.close
+
+      mail_store = make_mail_store
+      assert_equal(false, mail_store.abort_transaction?)
+      mail_store.close
+    end
+
+    def test_recovery_empty
+      mail_store = make_mail_store
+      assert_equal(false, mail_store.abort_transaction?)
+      assert_raise(RuntimeError) {
+        mail_store.transaction do
+          raise 'abort'
+        end
+      }
+      assert_equal(true, mail_store.abort_transaction?)
+      mail_store.close
+
+      mail_store = make_mail_store
+      assert_equal(true, mail_store.abort_transaction?)
+      mail_store.recovery_data(logger: @logger)
+      assert_equal(false, mail_store.abort_transaction?)
+      mail_store.close
+    end
+
+    def test_recovery_some_msgs_mboxes
+      mail_store = make_mail_store
+      inbox_id = mail_store.add_mbox('INBOX')
+      mail_store.add_msg(inbox_id, 'foo')
+      mail_store.add_msg(inbox_id, 'bar')
+      mail_store.add_msg(inbox_id, 'baz')
+      mail_store.add_mbox('foo')
+      mail_store.add_mbox('bar')
+
+      assert_equal(false, mail_store.abort_transaction?)
+      assert_raise(RuntimeError) {
+        mail_store.transaction do
+          raise 'abort'
+        end
+      }
+      assert_equal(true, mail_store.abort_transaction?)
+      mail_store.close
+
+      mail_store = make_mail_store
+      assert_equal(true, mail_store.abort_transaction?)
+      mail_store.recovery_data(logger: @logger)
+      assert_equal(false, mail_store.abort_transaction?)
+      mail_store.close
+    end
+  end
+
+  class MailStorePoolRefCountTest < Test::Unit::TestCase
+    def setup
+      @kvs = Hash.new{|h, k| h[k] = {} }
+      @kvs_open = proc{|mbox_version, unique_user_id, db_name|
+        RIMS::Hash_KeyValueStore.new(@kvs["#{mbox_version}/#{unique_user_id[0, 7]}/#{db_name}"])
+      }
+      @mail_store_pool = RIMS::MailStore.build_pool(@kvs_open, @kvs_open)
+    end
+
+    def teardown
+      pp @kvs if $DEBUG
+    end
+
+    def assert_call_hook
+      call_count = 0
+      yield(proc{ call_count += 1 })
+      assert_equal(1, call_count, 'a hook should be called once.')
+    end
+    private :assert_call_hook
+
+    def test_holder_object_key
+      unique_user_id = RIMS::Authentication.unique_user_id('foo')
+      holder = @mail_store_pool.get(unique_user_id)
+      assert_equal(unique_user_id, holder.object_key)
+      assert_equal(unique_user_id, holder.unique_user_id)
+    end
+
+    def test_get
+      unique_user_id = RIMS::Authentication.unique_user_id('foo')
+      assert_call_hook{|hook|
+        @mail_store_pool.get(unique_user_id) { hook.call }
+      }
+    end
+
+    def test_get2
+      unique_user_id = RIMS::Authentication.unique_user_id('foo')
+      @mail_store_pool.get(unique_user_id)
+      @mail_store_pool.get(unique_user_id) { flunk }
+    end
+
+    def test_get_multiuser
+      unique_user_id = RIMS::Authentication.unique_user_id('foo')
+      unique_user_id2 = RIMS::Authentication.unique_user_id('bar')
+
+      assert_call_hook{|hook|
+        @mail_store_pool.get(unique_user_id) { hook.call }
+      }
+      assert_call_hook{|hook|
+        @mail_store_pool.get(unique_user_id2) { hook.call }
+      }
+
+      @mail_store_pool.get(unique_user_id) { flunk }
+      @mail_store_pool.get(unique_user_id2) { flunk }
+    end
+
+    def test_return_pool
+      unique_user_id = RIMS::Authentication.unique_user_id('foo')
+
+      holder = @mail_store_pool.get(unique_user_id)
+      assert_call_hook{|hook|
+        holder.return_pool{ hook.call }
+      }
+    end
+
+    def test_return_pool2
+      unique_user_id = RIMS::Authentication.unique_user_id('foo')
+
+      holders = []
+      holders << @mail_store_pool.get(unique_user_id)
+      holders << @mail_store_pool.get(unique_user_id)
+      holders << @mail_store_pool.get(unique_user_id)
+
+      holders.pop.return_pool{ flunk }
+      holders.shift.return_pool{ flunk }
+      assert_call_hook{|hook|
+        holders.pop.return_pool{ hook.call }
+      }
+    end
+
+    def test_return_pool_multiuser
+      unique_user_id = RIMS::Authentication.unique_user_id('foo')
+      unique_user_id2 = RIMS::Authentication.unique_user_id('bar')
+
+      holders = []
+      holders << @mail_store_pool.get(unique_user_id)
+      holders << @mail_store_pool.get(unique_user_id)
+      holders << @mail_store_pool.get(unique_user_id)
+
+      holders2 = []
+      holders2 << @mail_store_pool.get(unique_user_id2)
+      holders2 << @mail_store_pool.get(unique_user_id2)
+      holders2 << @mail_store_pool.get(unique_user_id2)
+
+      holders.pop.return_pool{ flunk }
+      holders2.shift.return_pool{ flunk }
+      holders.pop.return_pool{ flunk }
+      holders2.shift.return_pool{ flunk }
+      assert_call_hook{|hook|
+        holders2.shift.return_pool{ hook.call }
+      }
+      assert_call_hook{|hook|
+        holders.pop.return_pool{ hook.call }
+      }
+    end
+
+    def test_cycle
+      unique_user_id = RIMS::Authentication.unique_user_id('foo')
+
+      holders = []
+      assert_call_hook{|hook|
+        holders << @mail_store_pool.get(unique_user_id) { hook.call }
+      }
+      holders << @mail_store_pool.get(unique_user_id) { flunk }
+      holders << @mail_store_pool.get(unique_user_id) { flunk }
+
+      holders.pop.return_pool{ flunk }
+      holders.pop.return_pool{ flunk }
+      assert_call_hook{|hook|
+        holders.pop.return_pool{ hook.call }
+      }
+
+      assert_call_hook{|hook|
+        holders << @mail_store_pool.get(unique_user_id) { hook.call }
+      }
+      holders << @mail_store_pool.get(unique_user_id) { flunk }
+
+      holders.shift.return_pool{ flunk }
+      assert_call_hook{|hook|
+        holders.shift.return_pool{ hook.call }
+      }
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End: