dk-bdb 0.2.4

data/lib/bdb/result_set.rb

@@ -0,0 +1,41 @@
+class Bdb::ResultSet
+  class LimitReached < Exception; end
+  
+  def initialize(opts, &block)
+    @block  = block
+    @count  = 0
+    @limit  = opts[:limit] || opts[:per_page]
+    @limit  = @limit.to_i if @limit
+    @offset = opts[:offset] || (opts[:page] ? @limit * (opts[:page] - 1) : 0)
+    @offset = @offset.to_i if @offset
+    
+    if @group = opts[:group]
+      raise 'block not supported with group' if @block     
+      @results = hash_class.new
+    else
+      @results = []
+    end
+  end
+  attr_reader :count, :group, :limit, :offset, :results
+  
+  def hash_class
+    @hash_class ||= defined?(ActiveSupport::OrderedHash) ? ActiveSupport::OrderedHash : Hash
+  end
+  
+  def <<(item)
+    @count += 1
+    return if count <= offset
+    
+    raise LimitReached if limit and count > limit + offset
+    
+    if group
+      key = item.bdb_locator_key
+      group_key = group.is_a?(Fixnum) ? key[0,group] : key
+      (results[group_key] ||= []) << item
+    elsif @block
+      @block.call(item)
+    else
+      results << item
+    end
+  end
+end

data/test/benchmark.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+require File.dirname(__FILE__) + '/../lib/bdb/simple'
+require 'benchmark'
+
+N = 10_000
+A = [5, 6, "foo", :bar, "bar", {}, :foo, [1,2,4], true, [1,2,3], false, [1], [2], nil].collect {|i| Marshal.dump(i)}
+
+puts "compare_absolute (#{N} times)"
+t = Benchmark.measure do
+  N.times do
+    A.sort {|a,b| Bdb::Simple.compare_absolute(Marshal.load(a), Marshal.load(b)) }
+  end
+end
+puts t
+
+puts "compare_hash (#{N} times)"
+t = Benchmark.measure do
+  N.times do
+    A.sort {|a,b| Marshal.load(a).hash <=> Marshal.load(b).hash }
+  end
+end
+puts t
+
+puts "compare_raw (#{N} times)"
+t = Benchmark.measure do
+  N.times do
+    A.sort
+  end
+end
+puts t
+

data/test/cursor_test.rb

@@ -0,0 +1,150 @@
+require 'test_helper'
+
+class CursorTest < Test::Unit::TestCase
+  
+  def setup
+    mkdir File.join(File.dirname(__FILE__), 'tmp')
+    @db = Bdb::Db.new
+    @db.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'test.db'), nil, Bdb::Db::BTREE, Bdb::DB_CREATE, 0)    
+    10.times { |i| @db.put(nil, i.to_s, "data-#{i}", 0)}
+    @cursor = @db.cursor(nil, 0)
+  end
+  
+  def teardown
+    @cursor.close if @cursor
+    assert(@db.close(0)) if @db
+    rm_rf File.join(File.dirname(__FILE__), 'tmp')
+  end
+
+  def test_get
+    key, value = @cursor.get(nil, nil, Bdb::DB_FIRST)
+    assert_equal '0', key
+    assert_equal 'data-0', value
+  end
+
+  def test_get_range
+    keys = []
+    key, value = @cursor.get("4", nil, Bdb::DB_SET_RANGE)
+    while key and key <= "9"
+      keys << key
+      key, value = @cursor.get(nil, nil, Bdb::DB_NEXT)
+    end
+
+    assert_equal (4..9).collect {|i| i.to_s}, keys
+  end
+  
+  def test_pget
+    @db1 = Bdb::Db.new
+    @db1.flags = Bdb::DB_DUPSORT
+    @db1.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'test1.db'), nil, Bdb::Db::HASH, Bdb::DB_CREATE, 0)
+
+    @db.associate(nil, @db1, 0, proc { |sdb, key, data| key.split('-')[0] })
+    
+    @db.put(nil, '1234-5678', 'data', 0)
+    @db.put(nil, '5678-1234', 'atad', 0)
+    
+    @cursor1 = @db1.cursor(nil, 0)
+    key, pkey, value = @cursor1.pget(nil, nil, Bdb::DB_FIRST)
+    assert_equal '1234', key
+    assert_equal '1234-5678', pkey
+    assert_equal 'data', value
+    
+    @cursor1.close
+    @db1.close(0)
+  end
+  
+  def test_put
+    @cursor.put('10_000', 'data-10_000', Bdb::DB_KEYLAST)
+    value = @db.get(nil, '10_000', nil, 0)
+    assert_equal 'data-10_000', value
+  end
+  
+  def test_del
+    key, value = @cursor.get(nil, nil, Bdb::DB_FIRST) 
+    value = @db.get(nil, '0', nil, 0)
+    assert_equal '0', key
+    assert_equal 'data-0', value
+    @cursor.del
+    value = @db.get(nil, '0', nil, 0)
+    assert_nil value
+  end
+  
+  def test_count
+    @cursor.get(nil, nil, Bdb::DB_FIRST) 
+    assert_equal 1, @cursor.count
+  end  
+
+  def test_get_all_in_order
+    all = []
+    while pair = @cursor.get(nil, nil, Bdb::DB_NEXT)      
+      all << pair.first
+    end
+    assert_equal (0..9).collect {|i| i.to_s}, all
+  end
+
+  def test_get_all_with_btree_compare
+    @db1 = Bdb::Db.new
+    @db1.btree_compare = proc {|db, key1, key2| key2 <=> key1}
+    @db1.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'test1.db'), nil, Bdb::Db::BTREE, Bdb::DB_CREATE, 0)    
+    10.times { |i| @db1.put(nil, i.to_s, "data-#{i}", 0)}
+    @cursor1 = @db1.cursor(nil, 0)
+
+    all = []
+    while pair = @cursor1.get(nil, nil, Bdb::DB_NEXT)      
+      all << pair.first
+    end
+    assert_equal (0..9).collect {|i| i.to_s}.reverse, all
+    @cursor1.close
+    @db1.close(0)
+  end
+
+  def test_btree_compare_raises_if_fixnum_not_returned
+    @db1 = Bdb::Db.new
+    @db1.btree_compare = proc {|db, key1, key2| key1}
+    @db1.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'test1.db'), nil, Bdb::Db::BTREE, Bdb::DB_CREATE, 0)    
+
+    assert_raises(TypeError) do
+      @db1.put(nil, "no", "way", 0)
+      @db1.put(nil, "ho", "say", 0)
+    end
+    @db1.close(Bdb::DB_NOSYNC)
+  end
+
+  def test_join
+    @personnel_db = Bdb::Db.new
+    @personnel_db.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'personnel_db.db'), nil, Bdb::Db::HASH, Bdb::DB_CREATE, 0)
+
+    @names_db = Bdb::Db.new
+    @names_db.flags = Bdb::DB_DUPSORT
+    @names_db.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'names_db.db'), nil, Bdb::Db::HASH, Bdb::DB_CREATE, 0)
+
+    @jobs_db = Bdb::Db.new
+    @jobs_db.flags = Bdb::DB_DUPSORT
+    @jobs_db.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'jobs_db.db'), nil, Bdb::Db::HASH, Bdb::DB_CREATE, 0)
+    
+    [{:ssn => '111-11-1111', :lastname => 'Smith',  :job => 'welder'},
+     {:ssn => '222-22-2222', :lastname => 'Jones', :job => 'welder'},
+     {:ssn => '333-33-3333', :lastname => 'Smith', :job => 'painter'}].each do |e|
+      @personnel_db.put(nil, e[:ssn], Marshal.dump([e[:ssn], e[:lastname], e[:job]]), 0)
+      @names_db.put(nil, e[:lastname], e[:ssn], 0)
+      @jobs_db.put(nil, e[:job], e[:ssn], 0)
+    end
+    
+    @name_cursor = @names_db.cursor(nil, 0)
+    @name_cursor.get('Smith', nil, Bdb::DB_SET)
+    assert_equal 2, @name_cursor.count
+    @job_cursor = @jobs_db.cursor(nil, 0)
+    @job_cursor.get('welder', nil, Bdb::DB_SET)
+    assert_equal 2, @job_cursor.count
+    @personnel_cursor = @personnel_db.join([@name_cursor, @job_cursor], 0)
+    assert_equal '111-11-1111', @personnel_cursor.get(nil, nil, 0).first
+
+    @personnel_cursor.close
+    @name_cursor.close
+    @job_cursor.close
+    
+    @jobs_db.close(0)
+    @names_db.close(0)
+    @personnel_db.close(0)
+  end
+end

data/test/database_test.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/database_test_helper'
+
+TMPDIR = File.dirname(__FILE__) + '/tmp'
+FileUtils.rmtree TMPDIR
+FileUtils.mkdir  TMPDIR
+
+class DatabaseTest < Test::Unit::TestCase
+  include DatabaseTestHelper
+
+  def setup
+    @db = Bdb::Database.new('foo', :path => TMPDIR)
+    @db.truncate!
+  end
+  
+  def teardown
+    @db.close
+  end
+end

data/test/database_test_helper.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+module DatabaseTestHelper
+  def db
+    @db
+  end
+
+  def test_set_and_get
+    assert_equal nil, db['foo']
+    assert_equal [],  db.get('foo')
+
+    db.set('foo', [1,2,3])
+    assert_equal [1,2,3], db['foo']
+    assert_equal [[1,2,3]], db.get('foo')
+  end
+
+  def test_set_and_get_with_tuples
+    assert_equal [],  db.get(['foo', 1])
+    assert_equal [],  db.get(['foo', 2])
+
+    db.set(['foo', 1], [1,2,3])
+    assert_equal [[1,2,3]], db.get(['foo', 1])
+
+    db.set(['foo', 2], [3,4,5])
+    assert_equal [[3,4,5]], db.get(['foo', 2])
+
+    assert_equal [[1,2,3], [3,4,5]], db.get('foo', :partial => true)
+  end
+
+  def test_get_with_ranges
+    100.times do |i|
+      db.set([:foo, i], {:id => i, :type => 'foo'})
+    end
+
+    assert_equal (17..34).to_a, db.get([:foo, 17]..[:foo, 34]).collect {|r| r[:id]}
+  end
+end

data/test/db_test.rb

@@ -0,0 +1,157 @@
+require 'test_helper'
+
+class DbTest < Test::Unit::TestCase
+
+  def setup
+    mkdir File.join(File.dirname(__FILE__), 'tmp')
+    @db = Bdb::Db.new
+    @db.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'test.db'), nil, Bdb::Db::BTREE, Bdb::DB_CREATE, 0)
+  end
+  
+  def teardown
+    assert(@db.close(0)) if @db
+    rm_rf File.join(File.dirname(__FILE__), 'tmp')
+  end
+  
+  def test_put_and_get
+    @db.put(nil, 'key', 'data', 0)
+    result = @db.get(nil, 'key', nil, 0)
+    assert_equal 'data', result
+  end
+  
+  def test_del
+    @db.put(nil, 'key', 'data', 0)
+    result = @db.get(nil, 'key', nil, 0)
+    assert_equal 'data', result
+    @db.del(nil, 'key', 0)    
+    result = @db.get(nil, 'key', nil, 0)
+    assert_nil result
+  end
+  
+  def test_flags_set_and_get
+    @db1 = Bdb::Db.new
+    @db1.flags = Bdb::DB_DUPSORT
+    assert Bdb::DB_DUPSORT, @db1.flags
+  end
+    
+  def test_associate_and_pget
+    @db1 = Bdb::Db.new
+    @db1.flags = Bdb::DB_DUPSORT
+    @db1.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'test1.db'), nil, Bdb::Db::HASH, Bdb::DB_CREATE, 0)
+
+    @db.associate(nil, @db1, 0, proc { |sdb, key, data| key.split('-')[0] })
+    
+    @db.put(nil, '1234-5678', 'data', 0)
+    @db.put(nil, '5678-1234', 'atad', 0)
+    
+    result = @db.get(nil, '1234-5678', nil, 0)
+    assert_equal 'data', result
+    result = @db1.get(nil, '5678', nil, 0)
+    assert_equal 'atad', result
+    
+    result = @db1.pget(nil, '1234', nil, 0)
+    assert_equal ['1234-5678', 'data'], result
+    
+    @db1.close(0)
+  end
+
+  def test_associate_with_multiple_keys
+    @db1 = Bdb::Db.new
+    @db1.flags = Bdb::DB_DUPSORT
+    @db1.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'test1.db'), nil, Bdb::Db::HASH, Bdb::DB_CREATE, 0)
+
+    @db.associate(nil, @db1, 0, proc { |sdb, key, data| key.split('-') })
+    
+    @db.put(nil, '1234-5678', 'data', 0)
+    @db.put(nil, '8765-4321', 'atad', 0)
+    
+    result = @db.get(nil, '1234-5678', nil, 0)
+    assert_equal 'data', result
+    result = @db1.get(nil, '5678', nil, 0)
+    assert_equal 'data', result
+    result = @db1.get(nil, '1234', nil, 0)
+    assert_equal 'data', result
+    result = @db1.get(nil, '8765', nil, 0)
+    assert_equal 'atad', result
+    result = @db1.get(nil, '4321', nil, 0)
+    assert_equal 'atad', result
+    
+    @db1.close(0)
+  end
+
+  def test_aset_and_aget
+    @db['key'] = 'data'
+    result = @db.get(nil, 'key', nil, 0)
+    assert_equal 'data', result
+    result = @db['key']
+    assert_equal 'data', result
+    @db['key'] = 'data1'
+    result = @db['key']
+    assert_equal 'data1', result
+  end
+  
+  def test_get_byteswapped
+    @db.get_byteswapped
+  end
+  
+  def test_get_type
+    assert_equal Bdb::Db::BTREE, @db.get_type
+  end
+  
+  def test_remove
+    @db1 = Bdb::Db.new
+    @db1.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'other_test.db'), nil, Bdb::Db::BTREE, Bdb::DB_CREATE, 0)
+    @db1.close(0)
+    Bdb::Db.new.remove(File.join(File.dirname(__FILE__), 'tmp', 'other_test.db'), nil, 0)
+    assert !File.exists?(File.join(File.dirname(__FILE__), 'tmp', 'other_test.db'))
+  end
+  
+  def test_key_range
+    10.times { |i| @db.put(nil, i.to_s, 'data', 0) }
+    @db.key_range(nil, '2', 0)
+  end
+  
+  def test_rename
+    @db1 = Bdb::Db.new
+    @db1.open(nil, File.join(File.dirname(__FILE__), 'tmp', 'other_test.db'), nil, Bdb::Db::BTREE, Bdb::DB_CREATE, 0)
+    @db1.close(0)
+    assert Bdb::Db.new.rename(File.join(File.dirname(__FILE__), 'tmp', 'other_test.db'), nil, File.join(File.dirname(__FILE__), 'tmp', 'other2_test.db'), 0)
+    assert File.exists?(File.join(File.dirname(__FILE__), 'tmp', 'other2_test.db'))
+  end
+  
+  def test_pagesize_get_and_set
+    @db1 = Bdb::Db.new
+    @db1.pagesize = 1024
+    assert_equal 1024, @db1.pagesize
+  end
+  
+  def test_h_ffactor_get_and_set
+    @db1 = Bdb::Db.new
+    @db1.h_ffactor = 5
+    assert_equal 5, @db1.h_ffactor
+  end
+  
+  def test_h_nelem_get_and_set
+    @db1 = Bdb::Db.new
+    @db1.h_nelem = 10_000
+    assert_equal 10_000, @db1.h_nelem
+  end
+  
+  def test_sync
+    assert @db.sync
+  end
+  
+  def test_truncate
+    @db.put(nil, 'key', 'data', 0)
+    result = @db.get(nil, 'key', nil, 0)
+    assert_equal 'data', result
+    @db.truncate(nil)
+    result = @db.get(nil, 'key', nil, 0)
+    assert_nil result    
+  end
+  
+  def test_compact
+    assert @db.compact(nil, nil, nil, nil, 0)
+  end  
+  
+end

data/test/deadlock_test.rb

@@ -0,0 +1,125 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+DIR = '/tmp/bdb_deadlock_test'
+Bdb::Environment.config :path => DIR, :cache_size => 1 * 1024 * 1024, :page_size => 512
+
+class DeadlockTest < Test::Unit::TestCase
+  def setup
+    FileUtils.rmtree DIR
+    FileUtils.mkdir  DIR
+    Bdb::Environment[DIR].close      
+    @db = Bdb::Database.new('foo')
+  end
+
+  attr_reader :db
+
+  N = 5000 # total number of records
+  R = 10   # number of readers
+  W = 10   # number of writers
+  T = 20   # reads per transaction
+  L = 100  # logging frequency
+
+  def test_detect_deadlock
+    pids = []
+
+    W.times do |n|
+      pids << fork(&writer)
+    end
+
+    sleep(1)
+
+    R.times do
+      pids << fork(&reader)
+    end
+
+    # Make sure that all processes finish with no errors.
+    pids.each do |pid|
+      Process.wait(pid)
+      assert_equal status, $?.exitstatus
+    end
+  end
+
+  C = 10
+  def test_detect_unclosed_resources
+    threads = []
+
+    threads << Thread.new do
+      C.times do
+        sleep(10)
+
+        pid = fork do
+          cursor = db.db.cursor(nil, 0)
+          cursor.get(nil, nil, Bdb::DB_FIRST)
+          exit!(1)
+        end
+        puts "\n====simulating exit with unclosed resources ===="
+        Process.wait(pid)
+        assert_equal 1, $?.exitstatus
+      end
+    end
+
+    threads << Thread.new do
+      C.times do
+        pid = fork(&writer(1000))
+        Process.wait(pid)
+        assert [0,9].include?($?.exitstatus)
+      end
+    end
+
+    sleep(3)
+
+    threads << Thread.new do
+      C.times do
+        pid = fork(&reader(1000))
+        Process.wait(pid)
+        assert [0,9].include?($?.exitstatus)
+      end
+    end
+    
+    threads.each {|t| t.join}
+  end
+
+  def reader(n = N)
+    lambda do
+      T.times do
+        (1...n).to_a.shuffle.each_slice(T) do |ids|
+          db.transaction do
+            ids.each {|id| db.get(id)}
+          end
+          log('r')
+        end
+      end
+      db.close_environment
+    end
+  end
+
+  def writer(n = N)
+    lambda do
+      (1...n).to_a.shuffle.each do |id|
+        db.transaction do
+          begin
+            db.set(id, {:bar => "bar" * 1000 + " ayn #{rand}"})
+          rescue Bdb::DbError => e
+            if e.code == Bdb::DB_KEYEXIST
+              db.delete(id)
+              retry
+            else
+              raise(e)
+            end
+          end
+        end
+        log('w')
+      end
+      db.close_environment
+    end
+  end
+
+  def log(action)
+    @count ||= Hash.new(0)
+    if @count[action] % L == 0
+      print action.to_s
+      $stdout.flush
+    end
+    @count[action] += 1
+  end
+end

data/test/env_test.rb

@@ -0,0 +1,101 @@
+require 'test_helper'
+
+class EnvTest < Test::Unit::TestCase
+    
+  def test_cachesize
+    env = Bdb::Env.new(0)
+    env.cachesize = 1024*1024*500
+    assert_equal 1024*1024*500, env.cachesize
+
+    env.cachesize = 1024*1024*1024*3
+    assert_equal 1024*1024*1024*3, env.cachesize
+
+    env.cachesize = 1024*1024*1024*3+1
+    assert_equal 1024*1024*1024*3+1, env.cachesize
+  end
+  
+  def test_flags
+    env = Bdb::Env.new(0)
+
+    env.flags_on = Bdb::DB_AUTO_COMMIT | Bdb::DB_DSYNC_DB
+    assert_equal Bdb::DB_AUTO_COMMIT | Bdb::DB_DSYNC_DB, env.flags    
+
+    env.flags_off = Bdb::DB_AUTO_COMMIT | Bdb::DB_DSYNC_DB
+    assert_equal 0, env.flags    
+  end
+    
+  def test_list_dbs
+    env = Bdb::Env.new(0)
+    assert env.list_dbs.empty?
+    
+    db = env.db
+    assert_equal db, env.list_dbs.first
+    db.close(0)
+  end
+    
+  def test_set_and_get_timeout
+    env = Bdb::Env.new(0)
+    env.set_timeout(10, Bdb::DB_SET_LOCK_TIMEOUT)
+    assert_equal 10, env.get_timeout(Bdb::DB_SET_LOCK_TIMEOUT)
+  end
+  
+  def test_set_and_get_tx_max
+    env = Bdb::Env.new(0)
+    env.set_tx_max(100)
+    assert_equal 100, env.get_tx_max
+  end
+  
+  def test_set_and_get_lk_detect
+    env = Bdb::Env.new(0)
+    env.set_lk_detect(Bdb::DB_LOCK_MAXWRITE)
+    assert_equal Bdb::DB_LOCK_MAXWRITE, env.get_lk_detect
+  end
+    
+  def test_set_and_get_lk_max_locks
+    env = Bdb::Env.new(0)
+    env.set_lk_max_locks(10_000)
+    assert_equal 10_000, env.get_lk_max_locks
+  end
+  
+  def test_set_and_get_lk_max_objects
+    env = Bdb::Env.new(0)
+    env.set_lk_max_objects(10_000)
+    assert_equal 10_000, env.get_lk_max_objects
+  end
+  
+  def test_set_and_get_shm_key
+    env = Bdb::Env.new(0)
+    env.set_shm_key(2506400)
+    assert_equal 2506400, env.get_shm_key
+  end
+    
+  def test_set_and_get_data_dir
+    env = Bdb::Env.new(0)
+    env.set_data_dir('/tmp')
+    assert_equal ['/tmp'], env.get_data_dirs
+  end
+  
+  def test_set_lg_dir
+    env = Bdb::Env.new(0)
+    env.set_lg_dir('/tmp')
+    assert_equal '/tmp', env.get_lg_dir
+  end
+  
+  def test_set_tmp_dir
+    env = Bdb::Env.new(0)
+    env.set_tmp_dir('/tmp')
+    assert_equal '/tmp', env.get_tmp_dir    
+  end
+
+  def test_get_home
+    env = Bdb::Env.new(0)
+    tmp_dir = File.expand_path(File.join(File.dirname(__FILE__), 'tmp'))
+    mkdir_p tmp_dir
+    env.open(tmp_dir, Bdb::DB_CREATE, 0);
+    assert_equal tmp_dir, env.get_home
+    env.close
+  ensure
+    rm_rf tmp_dir
+  end
+  
+end

data/test/replication_test.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/database_test_helper'
+
+MASTER_DIR = '/tmp/bdb_rep_test_master'
+CLIENT_DIR = '/tmp/bdb_rep_test_client'
+FileUtils.rmtree MASTER_DIR; FileUtils.mkdir MASTER_DIR; 
+FileUtils.rmtree CLIENT_DIR; FileUtils.mkdir CLIENT_DIR
+
+MASTER = 'localhost:8888'
+CLIENT = 'localhost:8889'
+
+N = 100
+
+class ReplicationTest < Test::Unit::TestCase
+  def setup
+    Bdb::Environment.replicate CLIENT_DIR, :from => MASTER, :to => CLIENT, :host => CLIENT #, :verbose => true
+    
+    @pid = Process.fork do
+      Bdb::Environment.replicate MASTER_DIR, :from => MASTER, :to => CLIENT, :host => MASTER #, :verbose => true
+      db = Bdb::Database.new('foo', :path => MASTER_DIR)
+
+      N.times do |i|
+        db.set(i, i + 1)
+        log "m"
+        sleep 0.1
+      end
+      sleep 10
+    end
+  end
+  
+  def teardown
+    Process.kill(9, @pid)
+  end
+
+  def test_single_process_replication
+    db = Bdb::Database.new('foo', :path => CLIENT_DIR)
+    N.times do |i|
+      sleep 0.2
+      assert_equal i + 1, db[i]
+      log "c"
+    end
+  end
+
+  def log(action)
+    print action
+    $stdout.flush
+  end
+end