rims 0.2.1

data/test/test_daemon_status_file.rb

@@ -0,0 +1,169 @@
+# -*- coding: utf-8 -*-
+
+require 'fileutils'
+require 'pp' if $DEBUG
+require 'rims'
+require 'test/unit'
+
+module RIMS::Test
+  class DaemonStatusFileTest < Test::Unit::TestCase
+    def setup
+      @stat_path = "status.#{$$}"
+      @stat_file = RIMS::Daemon.new_status_file(@stat_path, exclusive: true)
+      @read_file = RIMS::Daemon.new_status_file(@stat_path, exclusive: false)
+      @ready_spin_lock = "ready_spin_lock.#{$$}"
+      @final_spin_lock = "final_spin_lock.#{$$}"
+    end
+
+    def teardown
+      FileUtils.rm_f(@stat_path)
+      FileUtils.rm_f(@ready_spin_lock)
+      FileUtils.rm_f(@final_spin_lock)
+    end
+
+    def test_lock_status
+      @stat_file.open{
+        assert_equal(false, @stat_file.locked?)
+        @stat_file.synchronize{
+          assert_equal(true, @stat_file.locked?)
+        }
+        assert_equal(false, @stat_file.locked?)
+      }
+    end
+
+    def test_should_be_locked
+      assert_raise(RuntimeError) {
+        @stat_file.should_be_locked
+      }
+
+      @stat_file.open{
+        @stat_file.synchronize{
+          @stat_file.should_be_locked
+        }
+      }
+    end
+
+    def test_should_not_be_locked
+      @stat_file.should_not_be_locked
+
+      @stat_file.open{
+        @stat_file.synchronize{
+          assert_raise(RuntimeError) {
+            @stat_file.should_not_be_locked
+          }
+        }
+      }
+    end
+
+    def test_lock_guard
+      @stat_file.open{
+        @stat_file.synchronize{
+          assert_raise(RuntimeError) {
+            @stat_file.lock
+          }
+        }
+      }
+    end
+
+    def test_unlock_guard
+      @stat_file.open{
+        assert_raise(RuntimeError) {
+          @stat_file.unlock
+        }
+      }
+    end
+
+    def another_process_exclusive_lock(write_text: nil)
+      FileUtils.touch(@ready_spin_lock)
+      FileUtils.touch(@final_spin_lock)
+
+      pid = Process.fork{
+        lock_file = RIMS::Daemon.new_status_file(@stat_path, exclusive: true)
+        lock_file.open{
+          lock_file.synchronize{
+            lock_file.write(write_text) if write_text
+            FileUtils.rm_f(@ready_spin_lock)
+            while (File.exist? @final_spin_lock)
+              # nothing to do.
+            end
+          }
+        }
+        exit!
+      }
+
+      while (File.exist? @ready_spin_lock)
+        # nothing to do.
+      end
+
+      begin
+        yield
+      ensure
+        FileUtils.rm_f(@final_spin_lock)
+        Process.waitpid(pid)
+      end
+    end
+    private :another_process_exclusive_lock
+
+    def test_exclusive_lock
+      another_process_exclusive_lock{
+        @stat_file.open{
+          assert_raise(RuntimeError) {
+            @stat_file.synchronize{
+              flunk("don't reach here.")
+            }
+          }
+        }
+      }
+    end
+
+    def test_readable_lock_status
+      assert_raise(Errno::ENOENT) {
+        @read_file.open
+      }
+
+      another_process_exclusive_lock{
+        @read_file.open{
+          assert_equal(true, @read_file.locked?)
+        }
+      }
+
+      @read_file.open{
+        assert_equal(false, @read_file.locked?)
+      }
+    end
+
+    def test_readable_should_be_locked
+      another_process_exclusive_lock{
+        @read_file.open{
+          @read_file.should_be_locked
+        }
+      }
+
+      @read_file.open{
+        assert_raise(RuntimeError) {
+          @read_file.should_be_locked
+        }
+      }
+    end
+
+    def test_write_read
+      another_process_exclusive_lock(write_text: "pid: #{$$}") {
+        @read_file.open{
+          assert_equal("pid: #{$$}", @read_file.read)
+          assert_equal("pid: #{$$}", @read_file.read, 'rewind')
+        }
+      }
+
+      @read_file.open{
+        assert_raise(RuntimeError) {
+          @read_file.read
+        }
+      }
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

data/test/test_daemon_waitpid.rb

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+
+require 'pp' if $DEBUG
+require 'test/unit'
+
+module RIMS::Test
+  class DaemonWaitpidTest < Test::Unit::TestCase
+    def setup
+      @child_pid_list = []
+    end
+
+    def teardown
+      for pid in @child_pid_list
+	begin
+	  unless (Process.waitpid(pid, Process::WNOHANG)) then
+	    Process.kill('KILL', pid)
+	    Process.wait
+	  end
+	rescue SystemCallError
+	  next
+	end
+      end
+    end
+
+    def fork_child_process
+      latch_in, latch_out = IO.pipe
+
+      pid = fork{
+	latch_out.close
+	latch_in.gets
+	yield
+	exit!
+      }
+      @child_pid_list << pid
+      latch_in.close
+
+      return latch_out, pid
+    end
+    private :fork_child_process
+
+    def until_child_process_exit
+      until (pid = yield)
+	# nothing to do.
+      end
+
+      pid
+    end
+    private :until_child_process_exit
+
+    def test_waitpid
+      latch_out1, pid1 = fork_child_process{ exit!(0) }
+      latch_out2, pid2 = fork_child_process{ exit!(1) }
+      latch_out3, pid3 = fork_child_process{ exit!(2) }
+
+      assert_nil(Process.waitpid(-1, Process::WNOHANG))
+
+      latch_out3.puts
+      assert_equal(pid3, until_child_process_exit{ Process.waitpid(-1) })
+
+      latch_out1.puts
+      assert_equal(pid1, until_child_process_exit{ Process.waitpid(-1) })
+
+      latch_out2.puts
+      assert_equal(pid2, until_child_process_exit{ Process.waitpid(-1) })
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End:

data/test/test_db.rb

@@ -0,0 +1,602 @@
+# -*- coding: utf-8 -*-
+
+require 'pp' if $DEBUG
+require 'rims'
+require 'set'
+require 'test/unit'
+
+module RIMS::Test
+  class DBMetaTest < Test::Unit::TestCase
+    def setup
+      @kvs = {}
+      @db = RIMS::DB::Meta.new(RIMS::Hash_KeyValueStore.new(@kvs))
+    end
+
+    def teardown
+      pp @kvs if $DEBUG
+    end
+
+    def test_dirty
+      assert_equal(false, @db.dirty?)
+
+      @db.dirty = true
+      assert_equal(true, @db.dirty?)
+
+      @db.dirty = false
+      assert_equal(false, @db.dirty?)
+    end
+
+    def test_cnum
+      assert_equal(0, @db.cnum)
+      assert_equal(0, @db.cnum_succ!)
+      assert_equal(1, @db.cnum)
+    end
+
+    def test_msg_id
+      assert_equal(0, @db.msg_id)
+      assert_equal(0, @db.msg_id_succ!)
+      assert_equal(1, @db.msg_id)
+    end
+
+    def test_uidvalidity
+      assert_equal(1, @db.uidvalidity)
+      assert_equal(1, @db.uidvalidity_succ!)
+      assert_equal(2, @db.uidvalidity)
+    end
+
+    def test_mbox
+      assert_equal(1, @db.uidvalidity)
+      assert_equal([], @db.each_mbox_id.to_a)
+      assert_nil(@db.mbox_name(1))
+      assert_nil(@db.mbox_id('foo'))
+
+      id = @db.add_mbox('foo')
+      assert_equal(1, id)
+
+      assert_equal(2, @db.uidvalidity)
+      assert_equal([ 1 ], @db.each_mbox_id.to_a)
+      assert_equal('foo', @db.mbox_name(1))
+      assert_equal(1, @db.mbox_id('foo'))
+
+      assert_nil(@db.rename_mbox(1, 'foo'))
+
+      assert_equal(2, @db.uidvalidity)
+      assert_equal([ 1 ], @db.each_mbox_id.to_a)
+      assert_equal('foo', @db.mbox_name(1))
+      assert_equal(1, @db.mbox_id('foo'))
+
+      assert_not_nil(@db.rename_mbox(1, 'bar'))
+
+      assert_equal(2, @db.uidvalidity)
+      assert_equal([ 1 ], @db.each_mbox_id.to_a)
+      assert_equal('bar', @db.mbox_name(1))
+      assert_nil(@db.mbox_id('foo'))
+      assert_equal(1, @db.mbox_id('bar'))
+
+      assert_nil(@db.del_mbox(2))
+
+      assert_equal(2, @db.uidvalidity)
+      assert_equal([ 1 ], @db.each_mbox_id.to_a)
+      assert_equal('bar', @db.mbox_name(1))
+      assert_nil(@db.mbox_id('foo'))
+      assert_equal(1, @db.mbox_id('bar'))
+
+      assert_not_nil(@db.del_mbox(1))
+
+      assert_equal(2, @db.uidvalidity)
+      assert_equal([], @db.each_mbox_id.to_a)
+      assert_nil(@db.mbox_name(1))
+      assert_nil(@db.mbox_id('foo'))
+      assert_nil(@db.mbox_id('bar'))
+
+      id = @db.add_mbox('baz')
+      assert_equal(2, id)
+
+      assert_equal(3, @db.uidvalidity)
+      assert_equal([ 2 ], @db.each_mbox_id.to_a)
+      assert_nil(@db.mbox_name(1))
+      assert_equal('baz', @db.mbox_name(2))
+      assert_nil(@db.mbox_id('foo'))
+      assert_nil(@db.mbox_id('bar'))
+      assert_equal(2, @db.mbox_id('baz'))
+
+      id = @db.add_mbox('foo', mbox_id: 1)
+      assert_equal(1, id)
+
+      assert_equal(3, @db.uidvalidity)
+      assert_equal([ 1, 2 ], @db.each_mbox_id.sort)
+      assert_equal('foo', @db.mbox_name(1))
+      assert_equal('baz', @db.mbox_name(2))
+      assert_equal(1, @db.mbox_id('foo'))
+      assert_nil(@db.mbox_id('bar'))
+      assert_equal(2, @db.mbox_id('baz'))
+
+      id = @db.add_mbox('bar', mbox_id: 5)
+      assert_equal(5, id)
+
+      assert_equal(6, @db.uidvalidity)
+      assert_equal([ 1, 2, 5 ], @db.each_mbox_id.sort)
+      assert_equal('foo', @db.mbox_name(1))
+      assert_equal('baz', @db.mbox_name(2))
+      assert_equal('bar', @db.mbox_name(5))
+      assert_equal(1, @db.mbox_id('foo'))
+      assert_equal(5, @db.mbox_id('bar'))
+      assert_equal(2, @db.mbox_id('baz'))
+    end
+
+    def test_mbox_uid
+      id = @db.add_mbox('foo')
+      assert_equal(1, @db.mbox_uid(id))
+      assert_equal(1, @db.mbox_uid_succ!(id))
+      assert_equal(2, @db.mbox_uid(id))
+    end
+
+    def test_mbox_msg_num
+      id = @db.add_mbox('foo')
+      assert_equal(0, @db.mbox_msg_num(id))
+      @db.mbox_msg_num_increment(id)
+      assert_equal(1, @db.mbox_msg_num(id))
+      @db.mbox_msg_num_decrement(id)
+      assert_equal(0, @db.mbox_msg_num(id))
+    end
+
+    def test_mbox_flags
+      id = @db.add_mbox('foo')
+      assert_equal(0, @db.mbox_flag_num(id, 'flagged'))
+      @db.mbox_flag_num_increment(id, 'flagged')
+      assert_equal(1, @db.mbox_flag_num(id, 'flagged'))
+      @db.mbox_flag_num_decrement(id, 'flagged')
+      assert_equal(0, @db.mbox_flag_num(id, 'flagged'))
+      @db.mbox_flag_num_increment(id, 'flagged')
+      @db.mbox_flag_num_increment(id, 'flagged')
+      assert_equal(2, @db.mbox_flag_num(id, 'flagged'))
+      assert_not_nil(@db.clear_mbox_flag_num(id, 'flagged'))
+      assert_equal(0, @db.mbox_flag_num(id, 'flagged'))
+      assert_nil(@db.clear_mbox_flag_num(id, 'flagged'))
+      assert_equal(0, @db.mbox_flag_num(id, 'flagged'))
+    end
+
+    def test_msg_date
+      t = Time.mktime(2014, 3, 7, 18, 15, 56)
+      @db.set_msg_date(0, t)
+      assert_equal(t, @db.msg_date(0))
+      assert_not_nil(@db.clear_msg_date(0))
+      assert_nil(@db.clear_msg_date(0))
+    end
+
+    def test_msg_flag
+      assert_equal(false, @db.msg_flag(0, 'recent'))
+      assert_equal(false, @db.msg_flag(0, 'seen'))
+
+      @db.set_msg_flag(0, 'recent', true)
+      assert_equal(true, @db.msg_flag(0, 'recent'))
+      assert_equal(false, @db.msg_flag(0, 'seen'))
+
+      @db.set_msg_flag(0, 'seen', true)
+      assert_equal(true, @db.msg_flag(0, 'recent'))
+      assert_equal(true, @db.msg_flag(0, 'seen'))
+
+      @db.set_msg_flag(0, 'recent', false)
+      assert_equal(false, @db.msg_flag(0, 'recent'))
+      assert_equal(true, @db.msg_flag(0, 'seen'))
+
+      assert_not_nil(@db.clear_msg_flag(0))
+      assert_equal(false, @db.msg_flag(0, 'recent'))
+      assert_equal(false, @db.msg_flag(0, 'seen'))
+
+      assert_nil(@db.clear_msg_flag(0))
+      assert_equal(false, @db.msg_flag(0, 'recent'))
+      assert_equal(false, @db.msg_flag(0, 'seen'))
+    end
+
+    def test_msg_mbox_uid_mapping
+      assert_equal(1, @db.add_mbox('INBOX'))
+      assert_equal(2, @db.add_mbox('foo'))
+
+      assert_equal({}, @db.msg_mbox_uid_mapping(0))
+
+      assert_equal(1, @db.add_msg_mbox_uid(0, 1))
+      assert_equal({ 1 => [ 1 ].to_set
+                   }, @db.msg_mbox_uid_mapping(0))
+
+      assert_equal(2, @db.add_msg_mbox_uid(0, 1))
+      assert_equal({ 1 => [ 1, 2 ].to_set
+                   }, @db.msg_mbox_uid_mapping(0))
+
+      assert_equal(1, @db.add_msg_mbox_uid(0, 2))
+      assert_equal({ 1 => [ 1, 2 ].to_set,
+                     2 => [ 1 ].to_set
+                   }, @db.msg_mbox_uid_mapping(0))
+
+      assert_nil(@db.del_msg_mbox_uid(0, 2, 2))
+      assert_equal({ 1 => [ 1, 2 ].to_set,
+                     2 => [ 1 ].to_set
+                   }, @db.msg_mbox_uid_mapping(0))
+
+      assert_equal({ 1 => [ 1, 2 ].to_set
+                   }, @db.del_msg_mbox_uid(0, 2, 1))
+      assert_equal({ 1 => [ 1, 2 ].to_set
+                   }, @db.msg_mbox_uid_mapping(0))
+
+      assert_nil(@db.del_msg_mbox_uid(0, 2, 1))
+      assert_equal({ 1 => [ 1, 2 ].to_set
+                   }, @db.msg_mbox_uid_mapping(0))
+
+      assert_equal({ 1 => [ 2 ].to_set
+                   }, @db.del_msg_mbox_uid(0, 1, 1))
+      assert_equal({ 1 => [ 2 ].to_set
+                   }, @db.msg_mbox_uid_mapping(0))
+
+      assert_equal({}, @db.del_msg_mbox_uid(0, 1, 2))
+      assert_equal({}, @db.msg_mbox_uid_mapping(0))
+
+      assert_not_nil(@db.clear_msg_mbox_uid_mapping(0))
+      assert_equal({}, @db.msg_mbox_uid_mapping(0))
+
+      assert_nil(@db.clear_msg_mbox_uid_mapping(0))
+      assert_equal({}, @db.msg_mbox_uid_mapping(0))
+    end
+
+    def test_mbox_msg_num_auto_increment_decrement
+      inbox_id = @db.add_mbox('INBOX')
+      foo_id = @db.add_mbox('foo')
+
+      msg_a = 0
+      msg_b = 1
+
+      assert_equal(0, @db.mbox_msg_num(inbox_id))
+      assert_equal(0, @db.mbox_msg_num(foo_id))
+
+      assert_equal(1, @db.add_msg_mbox_uid(msg_a, inbox_id))
+
+      assert_equal(1, @db.mbox_msg_num(inbox_id))
+      assert_equal(0, @db.mbox_msg_num(foo_id))
+
+      assert_equal(2, @db.add_msg_mbox_uid(msg_b, inbox_id))
+
+      assert_equal(2, @db.mbox_msg_num(inbox_id))
+      assert_equal(0, @db.mbox_msg_num(foo_id))
+
+      assert_equal(3, @db.add_msg_mbox_uid(msg_a, inbox_id))
+
+      assert_equal(3, @db.mbox_msg_num(inbox_id))
+      assert_equal(0, @db.mbox_msg_num(foo_id))
+
+      assert_equal(1, @db.add_msg_mbox_uid(msg_a, foo_id))
+
+      assert_equal(3, @db.mbox_msg_num(inbox_id))
+      assert_equal(1, @db.mbox_msg_num(foo_id))
+
+      assert_equal({ inbox_id => [ 1, 3 ].to_set,
+                     foo_id => [ 1 ].to_set
+                   }, @db.msg_mbox_uid_mapping(msg_a))
+      assert_equal({ inbox_id => [ 2 ].to_set,
+                   }, @db.msg_mbox_uid_mapping(msg_b))
+
+      @db.del_msg_mbox_uid(msg_a, inbox_id, 1)
+
+      assert_equal(2, @db.mbox_msg_num(inbox_id))
+      assert_equal(1, @db.mbox_msg_num(foo_id))
+
+      @db.del_msg_mbox_uid(msg_a, foo_id, 1)
+
+      assert_equal(2, @db.mbox_msg_num(inbox_id))
+      assert_equal(0, @db.mbox_msg_num(foo_id))
+
+      @db.del_msg_mbox_uid(msg_b, inbox_id, 2)
+
+      assert_equal(1, @db.mbox_msg_num(inbox_id))
+      assert_equal(0, @db.mbox_msg_num(foo_id))
+
+      assert_equal({ inbox_id => [ 3 ].to_set,
+                   }, @db.msg_mbox_uid_mapping(msg_a))
+      assert_equal({}, @db.msg_mbox_uid_mapping(msg_b))
+    end
+
+    def test_mbox_flag_num_auto_increment_decrement
+      inbox_id = @db.add_mbox('INBOX')
+      foo_id = @db.add_mbox('foo')
+
+      msg_a = 0
+      msg_b = 1
+
+      assert_equal({}, @db.msg_mbox_uid_mapping(msg_a))
+      assert_equal({}, @db.msg_mbox_uid_mapping(msg_b))
+
+      assert_equal([ 0, 0 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(inbox_id, name) })
+      assert_equal([ 0, 0 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(foo_id, name) })
+
+      assert_equal(1, @db.add_msg_mbox_uid(msg_a, inbox_id))
+      assert_equal({ inbox_id => [ 1 ].to_set
+                   }, @db.msg_mbox_uid_mapping(msg_a))
+
+      assert_equal([ 0, 0 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(inbox_id, name) })
+      assert_equal([ 0, 0 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(foo_id, name) })
+
+      @db.set_msg_flag(msg_a, 'recent', true)
+
+      assert_equal([ 1, 0 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(inbox_id, name) })
+      assert_equal([ 0, 0 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(foo_id, name) })
+
+      assert_equal(1, @db.add_msg_mbox_uid(msg_a, foo_id))
+      assert_equal({ inbox_id => [ 1 ].to_set,
+                     foo_id => [ 1 ].to_set
+                   }, @db.msg_mbox_uid_mapping(msg_a))
+
+      assert_equal([ 1, 0 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(inbox_id, name) })
+      assert_equal([ 1, 0 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(foo_id, name) })
+
+      @db.set_msg_flag(msg_a, 'seen', true)
+
+      assert_equal([ 1, 1 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(inbox_id, name) })
+      assert_equal([ 1, 1 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(foo_id, name) })
+
+      @db.set_msg_flag(msg_b, 'recent', true)
+
+      assert_equal([ 1, 1 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(inbox_id, name) })
+      assert_equal([ 1, 1 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(foo_id, name) })
+
+      assert_equal(2, @db.add_msg_mbox_uid(msg_b, inbox_id))
+      assert_equal({ inbox_id => [ 2 ].to_set
+                   }, @db.msg_mbox_uid_mapping(msg_b))
+
+      assert_equal([ 2, 1 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(inbox_id, name) })
+      assert_equal([ 1, 1 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(foo_id, name) })
+
+      assert_equal(3, @db.add_msg_mbox_uid(msg_b, inbox_id))
+      assert_equal({ inbox_id => [ 2, 3 ].to_set
+                   }, @db.msg_mbox_uid_mapping(msg_b))
+
+      assert_equal([ 3, 1 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(inbox_id, name) })
+      assert_equal([ 1, 1 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(foo_id, name) })
+
+      @db.set_msg_flag(msg_b, 'seen', true)
+
+      assert_equal([ 3, 3 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(inbox_id, name) })
+      assert_equal([ 1, 1 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(foo_id, name) })
+
+      @db.set_msg_flag(msg_a, 'recent', false)
+
+      assert_equal([ 2, 3 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(inbox_id, name) })
+      assert_equal([ 0, 1 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(foo_id, name) })
+
+      @db.set_msg_flag(msg_b, 'recent', false)
+
+      assert_equal([ 0, 3 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(inbox_id, name) })
+      assert_equal([ 0, 1 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(foo_id, name) })
+
+      @db.del_msg_mbox_uid(msg_a, inbox_id, 1)
+      assert_equal({ foo_id => [ 1 ].to_set
+                   }, @db.msg_mbox_uid_mapping(msg_a))
+
+      assert_equal([ 0, 2 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(inbox_id, name) })
+      assert_equal([ 0, 1 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(foo_id, name) })
+
+      @db.del_msg_mbox_uid(msg_b, inbox_id, 2)
+      assert_equal({ inbox_id => [ 3 ].to_set
+                   }, @db.msg_mbox_uid_mapping(msg_b))
+
+      assert_equal([ 0, 1 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(inbox_id, name) })
+      assert_equal([ 0, 1 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(foo_id, name) })
+
+      @db.del_msg_mbox_uid(msg_a, foo_id, 1)
+      assert_equal({}, @db.msg_mbox_uid_mapping(msg_a))
+
+      assert_equal([ 0, 1 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(inbox_id, name) })
+      assert_equal([ 0, 0 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(foo_id, name) })
+
+      @db.del_msg_mbox_uid(msg_b, inbox_id, 3)
+      assert_equal({}, @db.msg_mbox_uid_mapping(msg_b))
+
+      assert_equal([ 0, 0 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(inbox_id, name) })
+      assert_equal([ 0, 0 ], %w[ recent seen ].map{|name| @db.mbox_flag_num(foo_id, name) })
+    end
+  end
+
+  class DBMessageTest < Test::Unit::TestCase
+    def setup
+      @kvs = {}
+      @db = RIMS::DB::Message.new(RIMS::Hash_KeyValueStore.new(@kvs))
+    end
+
+    def teardown
+      pp @kvs if $DEBUG
+    end
+
+    def test_msg
+      assert_equal([], @db.each_msg_id.to_a)
+      assert_nil(@db.msg_text(0))
+      assert_nil(@db.msg_text(1))
+      assert_nil(@db.msg_text(2))
+      assert_equal(false, (@db.msg_exist? 0))
+      assert_equal(false, (@db.msg_exist? 1))
+      assert_equal(false, (@db.msg_exist? 2))
+
+      @db.add_msg(0, 'foo')
+      assert_equal([ 0 ], @db.each_msg_id.to_a)
+      assert_equal('foo', @db.msg_text(0))
+      assert_nil(@db.msg_text(1))
+      assert_nil(@db.msg_text(2))
+      assert_equal(true, (@db.msg_exist? 0))
+      assert_equal(false, (@db.msg_exist? 1))
+      assert_equal(false, (@db.msg_exist? 2))
+
+      @db.add_msg(1, 'bar')
+      assert_equal([ 0, 1 ], @db.each_msg_id.to_a)
+      assert_equal('foo', @db.msg_text(0))
+      assert_equal('bar', @db.msg_text(1))
+      assert_nil(@db.msg_text(2))
+      assert_equal(true, (@db.msg_exist? 0))
+      assert_equal(true, (@db.msg_exist? 1))
+      assert_equal(false, (@db.msg_exist? 2))
+
+      @db.add_msg(2, 'baz')
+      assert_equal([ 0, 1, 2 ], @db.each_msg_id.to_a)
+      assert_equal('foo', @db.msg_text(0))
+      assert_equal('bar', @db.msg_text(1))
+      assert_equal('baz', @db.msg_text(2))
+      assert_equal(true, (@db.msg_exist? 0))
+      assert_equal(true, (@db.msg_exist? 1))
+      assert_equal(true, (@db.msg_exist? 2))
+
+      @db.del_msg(1)
+      assert_equal([ 0, 2 ], @db.each_msg_id.to_a)
+      assert_equal('foo', @db.msg_text(0))
+      assert_nil(@db.msg_text(1))
+      assert_equal('baz', @db.msg_text(2))
+      assert_equal(true, (@db.msg_exist? 0))
+      assert_equal(false, (@db.msg_exist? 1))
+      assert_equal(true, (@db.msg_exist? 2))
+
+      assert_raise(RuntimeError) { @db.del_msg(1) }
+    end
+  end
+
+  class DBMailboxTest < Test::Unit::TestCase
+    def setup
+      @kvs = {}
+      @db = RIMS::DB::Mailbox.new(RIMS::Hash_KeyValueStore.new(@kvs))
+    end
+
+    def teardown
+      pp @kvs if $DEBUG
+    end
+
+    def test_msg
+      assert_equal([], @db.each_msg_uid.to_a)
+      [ [ 1, false, nil, nil ],
+        [ 2, false, nil, nil ],
+        [ 3, false, nil, nil ]
+      ].each do |uid, exist, msg_id, deleted|
+        assert_equal(exist, (@db.msg_exist? uid))
+        assert_equal(msg_id, @db.msg_id(uid))
+        assert_equal(deleted, @db.msg_flag_deleted(uid))
+      end
+
+      @db.add_msg(1, 0)
+
+      assert_equal([ 1 ], @db.each_msg_uid.to_a)
+      [ [ 1, true, 0, false ],
+        [ 2, false, nil, nil ],
+        [ 3, false, nil, nil ]
+      ].each do |uid, exist, msg_id, deleted|
+        assert_equal(exist, (@db.msg_exist? uid))
+        assert_equal(msg_id, @db.msg_id(uid))
+        assert_equal(deleted, @db.msg_flag_deleted(uid))
+      end
+
+      @db.add_msg(2, 1)
+
+      assert_equal([ 1, 2 ], @db.each_msg_uid.to_a)
+      [ [ 1, true, 0, false ],
+        [ 2, true, 1, false ],
+        [ 3, false, nil, nil ]
+      ].each do |uid, exist, msg_id, deleted|
+        assert_equal(exist, (@db.msg_exist? uid))
+        assert_equal(msg_id, @db.msg_id(uid))
+        assert_equal(deleted, @db.msg_flag_deleted(uid))
+      end
+
+      @db.add_msg(3, 0)
+
+      assert_equal([ 1, 2, 3 ], @db.each_msg_uid.to_a)
+      [ [ 1, true, 0, false ],
+        [ 2, true, 1, false ],
+        [ 3, true, 0, false ]
+      ].each do |uid, exist, msg_id, deleted|
+        assert_equal(exist, (@db.msg_exist? uid))
+        assert_equal(msg_id, @db.msg_id(uid))
+        assert_equal(deleted, @db.msg_flag_deleted(uid))
+      end
+
+      @db.set_msg_flag_deleted(1, true)
+
+      [ [ 1, true, 0, true ],
+        [ 2, true, 1, false ],
+        [ 3, true, 0, false ]
+      ].each do |uid, exist, msg_id, deleted|
+        assert_equal(exist, (@db.msg_exist? uid))
+        assert_equal(msg_id, @db.msg_id(uid))
+        assert_equal(deleted, @db.msg_flag_deleted(uid))
+      end
+
+      @db.expunge_msg(1)
+
+      [ [ 1, false, nil, nil ],
+        [ 2, true, 1, false ],
+        [ 3, true, 0, false ]
+      ].each do |uid, exist, msg_id, deleted|
+        assert_equal(exist, (@db.msg_exist? uid))
+        assert_equal(msg_id, @db.msg_id(uid))
+        assert_equal(deleted, @db.msg_flag_deleted(uid))
+      end
+
+      assert_raise(RuntimeError) { @db.expunge_msg(1) }
+      assert_raise(RuntimeError) { @db.expunge_msg(2) }
+    end
+  end
+
+  class DBCoreTestReadAllTest < Test::Unit::TestCase
+    def setup
+      @kvs = {}
+      @builder = RIMS::KeyValueStore::FactoryBuilder.new
+      @builder.open{|name| RIMS::Hash_KeyValueStore.new(@kvs) }
+      @builder.use(RIMS::Checksum_KeyValueStore)
+      @cksum_kvs = @builder.factory.call('test')
+      @db = RIMS::DB::Core.new(@cksum_kvs)
+    end
+
+    def teardown
+      pp @kvs if $DEBUG
+    end
+
+    def test_test_read_all_empty
+      @db.test_read_all{|read_error|
+        flunk('no error.')
+      }
+    end
+
+    def test_test_read_all_good
+      @cksum_kvs['foo'] = 'apple'
+      @cksum_kvs['bar'] = 'banana'
+      @cksum_kvs['baz'] = 'orange'
+
+      @db.test_read_all{|read_error|
+        flunk('no error.')
+      }
+    end
+
+    def test_test_read_all_bad
+      @cksum_kvs['foo'] = 'apple'
+      @cksum_kvs['bar'] = 'banana'; @kvs['bar'] = 'banana'
+      @cksum_kvs['baz'] = 'orange'
+
+      count = 0
+      assert_raise(RuntimeError) {
+        @db.test_read_all{|read_error|
+          assert_kind_of(RuntimeError, read_error)
+          count += 1
+        }
+      }
+      assert_equal(1, count)
+
+      @cksum_kvs['foo'] = 'apple'; @kvs['foo'] = 'apple'
+      @cksum_kvs['bar'] = 'banana'
+      @cksum_kvs['baz'] = 'orange'; @kvs['baz'] = 'orange'
+
+      count = 0
+      assert_raise(RuntimeError) {
+        @db.test_read_all{|read_error|
+          assert_kind_of(RuntimeError, read_error)
+          count += 1
+        }
+      }
+      assert_equal(2, count)
+    end
+  end
+end
+
+# Local Variables:
+# mode: Ruby
+# indent-tabs-mode: nil
+# End: