gdbm 1.2 → 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d77e96cabac18ae26ee213c0cc34052096e1fd38
+  data.tar.gz: 790eb07656751d2b4ab5d3c785e3997d0296473c
+SHA512:
+  metadata.gz: 78271a2686aadce65e018a9d0656ed6bbc8de44d57ac3241c75257c2b88d9118557087186c5614b5f69cb4341af7bb9779365e1c10d3cd75fabf0e94414b8663
+  data.tar.gz: 1db72d78f9b8a2cca859dd0f98d2685b2718afb87c2112a9c2cbf80f7586234a86eea6fc6d4df0be3435df1fa64b2211f06aae1f654795c39a1c2c5f1cf4795e

data/README.md

@@ -1,6 +1,8 @@
 ## ffi-gdbm
 
-An attempt to make gdbm available beyond the C Ruby implementation.
+An attempt to make [gdbm](http://www.vivtek.com/gdbm/) available beyond the C Ruby implementation.
+
+Faithfully mimics MRI's standard library and is compatible with gdbm files produced by that version.
 
 ## Installing
 
@@ -8,11 +10,15 @@ You can download and use `gdbm.rb` anyhow you would like.
 
 You can also install it using Ruby Gems:
 
-`gem install gdbm --source http://gemcutter.org`
+`gem install gdbm`
 
 or, if using JRuby:
 
-`jgem install gdbm --source http://gemcutter.org`
+`jgem install gdbm`
+
+JRuby does not require further installation, but Rubinius will need the FFI gem:
+
+`gem install ffi`
 
 ## Notes
 
@@ -22,11 +28,16 @@ or, if using JRuby:
 
 ## Status
 
-Passing all tests with JRuby 1.4 and 1.5rc2 on 32-bit Linux. There may (or may not) be issues using 64-bit.
+Tests passing on 64 bit Linux with
+
+* JRuby 1.7.17
+* Rubinius 2.2.10 + FFI 1.9.6
 
-Passing all tests with MRI Ruby 1.8.7 and 1.9.1 with Ruby-FFI 0.5.4 (and 0.6.3) on 32-bit Linux.
+### Older Tests
 
-Does not currently work with Rubinius' FFI. Please let me know if this changes.
+Passing all tests with JRuby 1.4, 1.5.3, 1.6 on 32-bit Linux.
+
+Passing all tests with MRI Ruby 1.8.7, 1.9.1, 1.9.2 with Ruby-FFI 0.5.4, 0.6.3, 1.0.7 on 32-bit Linux.
 
 Something weird happens with temp files (used in tests) with JRuby on Ubuntu. For some reason, it gets permission denied when trying to delete them. Any thoughts on that would be helpful.
 
@@ -36,6 +47,13 @@ Further testing on other systems is welcome!
 
 Two sets of tests are included, copied straight from the MRI distribution. However, they do require the use of ObjectSpace, so this is how to run them with JRuby:
 
-`jruby -X+O -r lib/gdbm test/test_gdbm-1.8.7.rb`
+`jruby --1.8 -X+O -r lib/gdbm test/test_gdbm-1.8.7.rb`
+
+`jruby -X+O -r lib/gdbm test/test_gdbm-1.9.1.rb`
+
+## License
+
+Copyright (c), Justin Collins
 
-`jruby --1.9 -X+O -r lib/gdbm test/test_gdbm-1.9.1.rb`
+This library is released under the same tri-license (GPL/LGPL/CPL) as JRuby.
+Please see the COPYING file distributed with JRuby for details.

data/lib/gdbm.rb

@@ -149,11 +149,17 @@ module GDBM_FFI
 
   #Iterates over each key in the _file_.
   def self.each_key(file)
+    keys = []
     current = self.gdbm_firstkey file
     until current.value.nil?
-      yield current.value
+      if block_given?
+        yield current.value
+      else
+        keys << current.value
+      end
       current = self.gdbm_nextkey file, current
     end
+    block_given? ? nil : keys.each
   end
 
   #Iterates over each value in the _file_.
@@ -345,8 +351,8 @@ class GDBM
   alias :reject! :delete_if
 
   def each_key(&block)
-    GDBM_FFI.each_key file, &block
-    self
+    enumerator = GDBM_FFI.each_key(file, &block)
+    enumerator || self
   end
 
   def each_pair(&block)

metadata

@@ -1,69 +1,48 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: gdbm
-version: !ruby/object:Gem::Version 
-  hash: 11
-  prerelease: false
-  segments: 
-  - 1
-  - 2
-  version: "1.2"
+version: !ruby/object:Gem::Version
+  version: 1.3.0
 platform: ruby
-authors: 
+authors:
 - Justin Collins
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-05-03 00:00:00 -07:00
-default_executable: 
+date: 2014-12-14 00:00:00.000000000 Z
 dependencies: []
-
-description: This library provides a gdbm library compatible with the MRI standard library, but using Ruby-FFI rather than a C extension. This allows gdbm to easily be used from alternative Ruby implementations, such as JRuby. It can also be used with MRI, if there is some kind of need for that.
+description: This library provides a gdbm library compatible with the MRI standard
+  library, but using Ruby-FFI rather than a C extension. This allows gdbm to easily
+  be used from alternative Ruby implementations, such as JRuby. It can also be used
+  with MRI, if there is some kind of need for that.
 email: 
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - README.md
 - lib/gdbm.rb
-- test/test_gdbm-1.8.7.rb
-- test/test_gdbm-1.9.1.rb
-has_rdoc: true
 homepage: http://github.com/presidentbeef/ffi-gdbm
 licenses: []
-
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7.pre.1
+rubygems_version: 2.4.4
 signing_key: 
-specification_version: 3
-summary: Provides access to gdbm through Ruby-FFI, particularly for JRuby and other alternative Ruby implementations.
+specification_version: 4
+summary: Provides access to gdbm through Ruby-FFI, particularly for JRuby and other
+  alternative Ruby implementations.
 test_files: []
-

data/test/test_gdbm-1.8.7.rb

@@ -1,697 +0,0 @@
-require 'test/unit'
-
-begin
-#  require 'gdbm'
-rescue LoadError
-end
-
-if defined? GDBM
-
-  $stderr.puts "WARNING: Loaded non-FFI gdbm library (probably from the standard lib)." unless defined? GDBM_FFI
-
-  require 'tmpdir'
-  require 'fileutils'
-
-  class TestGDBM < Test::Unit::TestCase
-    def TestGDBM.uname_s
-      require 'rbconfig'
-      case Config::CONFIG['target_os']
-      when 'cygwin'
-        require 'Win32API'
-        uname = Win32API.new('cygwin1', 'uname', 'P', 'I')
-        utsname = ' ' * 100
-        raise 'cannot get system name' if uname.call(utsname) == -1
-
-        utsname.unpack('A20' * 5)[0]
-      else
-        Config::CONFIG['target_os']
-      end
-    end
-    SYSTEM = uname_s
-
-    def setup
-      @path = "tmptest_gdbm_"
-      assert_instance_of(GDBM, @gdbm = GDBM.new(@path))
-
-      # prepare to make readonly GDBM file
-      GDBM.open("tmptest_gdbm_rdonly", 0400) {|gdbm|
-        gdbm['foo'] = 'FOO'
-      }
-      assert_instance_of(GDBM, @gdbm_rdonly = GDBM.new("tmptest_gdbm_rdonly", nil))
-    end
-    def teardown
-      assert_nil(@gdbm.close)
-      assert_nil(@gdbm_rdonly.close)
-      ObjectSpace.each_object(GDBM) do |obj|
-        obj.close unless obj.closed?
-      end
-      File.delete *Dir.glob("*tmptest_gdbm*").to_a
-      p Dir.glob("*tmptest_gdbm*") if $DEBUG
-    end
-
-    def check_size(expect, gdbm=@gdbm)
-      assert_equal(expect, gdbm.size)
-      n = 0
-      gdbm.each { n+=1 }
-      assert_equal(expect, n)
-      if expect == 0
-        assert_equal(true, gdbm.empty?)
-      else
-        assert_equal(false, gdbm.empty?)
-      end
-    end
-
-    def have_fork?
-      begin
-        fork{}
-        true
-      rescue NotImplementedError
-        false
-      end
-    end
-
-    def test_s_new_has_no_block
-      # GDBM.new ignore the block
-      foo = true
-      assert_instance_of(GDBM, gdbm = GDBM.new("tmptest_gdbm") { foo = false })
-      assert_equal(foo, true)
-      assert_nil(gdbm.close)
-    end
-    def test_s_open_create_new
-      return if /^CYGWIN_9/ =~ SYSTEM
-
-      save_mask = File.umask(0)
-      begin
-        assert_instance_of(GDBM, gdbm = GDBM.open("tmptest_gdbm"))
-        gdbm.close
-        assert_equal(File.stat("tmptest_gdbm").mode & 0777, 0666)
-        assert_instance_of(GDBM, gdbm = GDBM.open("tmptest_gdbm2", 0644))
-        gdbm.close
-        assert_equal(File.stat("tmptest_gdbm2").mode & 0777, 0644)
-      ensure
-        File.umask save_mask
-      end
-    end
-    def test_s_open_no_create
-      assert_nil(gdbm = GDBM.open("tmptest_gdbm", nil),
-                 "this test is failed on libgdbm 1.8.0")
-    ensure
-      gdbm.close if gdbm
-    end
-    def test_s_open_3rd_arg
-      assert_instance_of(GDBM, gdbm = GDBM.open("tmptest_gdbm", 0644,
-                                                GDBM::FAST))
-      gdbm.close
-
-      # gdbm 1.8.0 specific
-      if defined? GDBM::SYNC
-        assert_instance_of(GDBM, gdbm = GDBM.open("tmptest_gdbm", 0644,
-                                                  GDBM::SYNC))
-        gdbm.close
-      end
-      # gdbm 1.8.0 specific
-      if defined? GDBM::NOLOCK
-        assert_instance_of(GDBM, gdbm = GDBM.open("tmptest_gdbm", 0644,
-                                                  GDBM::NOLOCK))
-        gdbm.close
-      end
-    end
-    def test_s_open_with_block
-      assert_equal(GDBM.open("tmptest_gdbm") { :foo }, :foo)
-    end
-    def test_s_open_lock
-      return unless have_fork?	# snip this test
-      pid = fork() {
-        assert_instance_of(GDBM, gdbm  = GDBM.open("tmptest_gdbm", 0644))
-        sleep 2
-      }
-      begin
-        sleep 1
-        assert_raise(Errno::EWOULDBLOCK) {
-          begin
-            assert_instance_of(GDBM, gdbm2 = GDBM.open("tmptest_gdbm", 0644))
-          rescue Errno::EAGAIN, Errno::EACCES
-            raise Errno::EWOULDBLOCK
-          end
-        }
-      ensure
-        Process.wait pid
-      end
-    end
-
-=begin
-    # Is it guaranteed on many OS?
-    def test_s_open_lock_one_process
-      # locking on one process
-      assert_instance_of(GDBM, gdbm  = GDBM.open("tmptest_gdbm", 0644))
-      assert_raise(Errno::EWOULDBLOCK) {
-        begin
-          GDBM.open("tmptest_gdbm", 0644)
-        rescue Errno::EAGAIN
-          raise Errno::EWOULDBLOCK
-        end
-      }
-    end
-=end
-
-    def test_s_open_nolock
-      # gdbm 1.8.0 specific
-      if not defined? GDBM::NOLOCK
-        return
-      end
-      return unless have_fork?	# snip this test
-
-      pid = fork() {
-        assert_instance_of(GDBM, gdbm  = GDBM.open("tmptest_gdbm", 0644,
-                                                  GDBM::NOLOCK))
-        sleep 2
-      }
-      sleep 1
-      begin
-        gdbm2 = nil
-        assert_nothing_raised(Errno::EWOULDBLOCK, Errno::EAGAIN, Errno::EACCES) {
-          assert_instance_of(GDBM, gdbm2 = GDBM.open("tmptest_gdbm", 0644))
-        }
-      ensure
-        Process.wait pid
-        gdbm2.close if gdbm2
-      end
-
-      p Dir.glob("tmptest_gdbm*") if $DEBUG
-
-      pid = Process.fork() {
-        assert_instance_of(GDBM, gdbm  = GDBM.open("tmptest_gdbm", 0644))
-        sleep 2
-      }
-      begin
-        sleep 1
-        gdbm2 = nil
-        assert_nothing_raised(Errno::EWOULDBLOCK, Errno::EAGAIN, Errno::EACCES) {
-          # this test is failed on Cygwin98 (???)
-          assert_instance_of(GDBM, gdbm2 = GDBM.open("tmptest_gdbm", 0644,
-                                                     GDBM::NOLOCK))
-        }
-      ensure
-        Process.wait pid
-        gdbm2.close if gdbm2
-      end
-    end
-
-    def test_s_open_error
-      return if /(ms|bcc)win|mingw|djgpp/ =~ RUBY_PLATFORM
-      assert_instance_of(GDBM, gdbm = GDBM.open("tmptest_gdbm", 0))
-      assert_raise(Errno::EACCES) {
-        GDBM.open("tmptest_gdbm", 0)
-      }
-      gdbm.close
-    end
-
-    def test_close
-      assert_instance_of(GDBM, gdbm = GDBM.open("tmptest_gdbm"))
-      assert_nil(gdbm.close)
-
-      # closed GDBM file
-      assert_raise(RuntimeError) { gdbm.close }
-    end
-
-    def test_aref
-      assert_equal('bar', @gdbm['foo'] = 'bar')
-      assert_equal('bar', @gdbm['foo'])
-
-      assert_nil(@gdbm['bar'])
-    end
-
-    def test_fetch
-      assert_equal('bar', @gdbm['foo']='bar')
-      assert_equal('bar', @gdbm.fetch('foo'))
-
-      # key not found
-      assert_raise(IndexError) {
-        @gdbm.fetch('bar')
-      }
-
-      # test for `ifnone' arg
-      assert_equal('baz', @gdbm.fetch('bar', 'baz'))
-
-      # test for `ifnone' block
-      assert_equal('foobar', @gdbm.fetch('bar') {|key| 'foo' + key })
-    end
-
-    def test_aset
-      num = 0
-      2.times {|i|
-        assert_equal('foo', @gdbm['foo'] = 'foo')
-        assert_equal('foo', @gdbm['foo'])
-        assert_equal('bar', @gdbm['foo'] = 'bar')
-        assert_equal('bar', @gdbm['foo'])
-
-        num += 1 if i == 0
-        assert_equal(num, @gdbm.size)
-
-        # assign nil
-        assert_equal('', @gdbm['bar'] = '')
-        assert_equal('', @gdbm['bar'])
-
-        num += 1 if i == 0
-        assert_equal(num, @gdbm.size)
-
-        # empty string
-        assert_equal('', @gdbm[''] = '')
-        assert_equal('', @gdbm[''])
-
-        num += 1 if i == 0
-        assert_equal(num, @gdbm.size)
-
-        # Fixnum
-        assert_equal('200', @gdbm['100'] = '200')
-        assert_equal('200', @gdbm['100'])
-
-        num += 1 if i == 0
-        assert_equal(num, @gdbm.size)
-
-        # Big key and value
-        assert_equal('y' * 100, @gdbm['x' * 100] = 'y' * 100)
-        assert_equal('y' * 100, @gdbm['x' * 100])
-
-        num += 1 if i == 0
-        assert_equal(num, @gdbm.size)
-      }
-    end
-
-    def test_index
-      assert_equal('bar', @gdbm['foo'] = 'bar')
-      assert_equal('foo', @gdbm.index('bar'))
-      assert_nil(@gdbm['bar'])
-    end
-
-    def test_values_at
-      keys = %w(foo bar baz)
-      values = %w(FOO BAR BAZ)
-      @gdbm[keys[0]], @gdbm[keys[1]], @gdbm[keys[2]] = values
-      assert_equal(values.reverse, @gdbm.values_at(*keys.reverse))
-    end
-
-    def test_select_with_block
-      keys = %w(foo bar baz)
-      values = %w(FOO BAR BAZ)
-      @gdbm[keys[0]], @gdbm[keys[1]], @gdbm[keys[2]] = values
-      ret = @gdbm.select {|k,v|
-        assert_equal(k.upcase, v)
-        k != "bar"
-      }
-      assert_equal([['baz', 'BAZ'], ['foo', 'FOO']],
-                    ret.sort)
-    end
-
-    def test_length
-      num = 10
-      assert_equal(0, @gdbm.size)
-      num.times {|i|
-        i = i.to_s
-        @gdbm[i] = i
-      }
-      assert_equal(num, @gdbm.size)
-
-      @gdbm.shift
-
-      assert_equal(num - 1, @gdbm.size)
-    end
-
-    def test_empty?
-      assert_equal(true, @gdbm.empty?)
-      @gdbm['foo'] = 'FOO'
-      assert_equal(false, @gdbm.empty?)
-    end
-
-    def test_each_pair
-      n = 0
-      @gdbm.each_pair { n += 1 }
-      assert_equal(0, n)
-
-      keys = %w(foo bar baz)
-      values = %w(FOO BAR BAZ)
-
-      @gdbm[keys[0]], @gdbm[keys[1]], @gdbm[keys[2]] = values
-
-      n = 0
-      ret = @gdbm.each_pair {|key, val|
-        assert_not_nil(i = keys.index(key))
-        assert_equal(val, values[i])
-
-        n += 1
-      }
-      assert_equal(keys.size, n)
-      assert_equal(@gdbm, ret)
-    end
-
-    def test_each_value
-      n = 0
-      @gdbm.each_value { n += 1 }
-      assert_equal(0, n)
-
-      keys = %w(foo bar baz)
-      values = %w(FOO BAR BAZ)
-
-      @gdbm[keys[0]], @gdbm[keys[1]], @gdbm[keys[2]] = values
-
-      n = 0
-      ret = @gdbm.each_value {|val|
-        assert_not_nil(key = @gdbm.index(val))
-        assert_not_nil(i = keys.index(key))
-        assert_equal(val, values[i])
-
-        n += 1
-      }
-      assert_equal(keys.size, n)
-      assert_equal(@gdbm, ret)
-    end
-
-    def test_each_key
-      n = 0
-      @gdbm.each_key { n += 1 }
-      assert_equal(0, n)
-
-      keys = %w(foo bar baz)
-      values = %w(FOO BAR BAZ)
-
-      @gdbm[keys[0]], @gdbm[keys[1]], @gdbm[keys[2]] = values
-
-      n = 0
-      ret = @gdbm.each_key {|key|
-        assert_not_nil(i = keys.index(key))
-        assert_equal(@gdbm[key], values[i])
-
-        n += 1
-      }
-      assert_equal(keys.size, n)
-      assert_equal(@gdbm, ret)
-    end
-
-    def test_keys
-      assert_equal([], @gdbm.keys)
-
-      keys = %w(foo bar baz)
-      values = %w(FOO BAR BAZ)
-
-      @gdbm[keys[0]], @gdbm[keys[1]], @gdbm[keys[2]] = values
-
-      assert_equal(keys.sort, @gdbm.keys.sort)
-      assert_equal(values.sort, @gdbm.values.sort)
-    end
-
-    def test_values
-      test_keys
-    end
-
-    def test_shift
-      assert_nil(@gdbm.shift)
-      assert_equal(0, @gdbm.size)
-
-      keys = %w(foo bar baz)
-      values = %w(FOO BAR BAZ)
-
-      @gdbm[keys[0]], @gdbm[keys[1]], @gdbm[keys[2]] = values
-
-      ret_keys = []
-      ret_values = []
-      while ret = @gdbm.shift
-        ret_keys.push ret[0]
-        ret_values.push ret[1]
-
-        assert_equal(keys.size - ret_keys.size, @gdbm.size)
-      end
-
-      assert_equal(keys.sort, ret_keys.sort)
-      assert_equal(values.sort, ret_values.sort)
-    end
-
-    def test_delete
-      keys = %w(foo bar baz)
-      values = %w(FOO BAR BAZ)
-      key = keys[1]
-
-      assert_nil(@gdbm.delete(key))
-      assert_equal(0, @gdbm.size)
-
-      @gdbm[keys[0]], @gdbm[keys[1]], @gdbm[keys[2]] = values
-
-      assert_equal('BAR', @gdbm.delete(key))
-      assert_nil(@gdbm[key])
-      assert_equal(2, @gdbm.size)
-
-      assert_nil(@gdbm.delete(key))
-
-      if /^CYGWIN_9/ !~ SYSTEM
-        assert_raise(GDBMError) {
-          @gdbm_rdonly.delete("foo")
-        }
-
-        assert_nil(@gdbm_rdonly.delete("bar"))
-      end
-    end
-    def test_delete_with_block
-      key = 'no called block'
-      @gdbm[key] = 'foo'
-      assert_equal('foo', @gdbm.delete(key) {|k| k.replace 'called block'})
-      assert_equal('no called block', key)
-      assert_equal(0, @gdbm.size)
-
-      key = 'no called block'
-      assert_equal(:blockval,
-                    @gdbm.delete(key) {|k| k.replace 'called block'; :blockval})
-      assert_equal('called block', key)
-      assert_equal(0, @gdbm.size)
-    end
-
-    def test_delete_if
-      v = "0"
-      100.times {@gdbm[v] = v; v = v.next}
-
-      ret = @gdbm.delete_if {|key, val| key.to_i < 50}
-      assert_equal(@gdbm, ret)
-      check_size(50, @gdbm)
-
-      ret = @gdbm.delete_if {|key, val| key.to_i >= 50}
-      assert_equal(@gdbm, ret)
-      check_size(0, @gdbm)
-
-      # break
-      v = "0"
-      100.times {@gdbm[v] = v; v = v.next}
-      check_size(100, @gdbm)
-      n = 0;
-      @gdbm.delete_if {|key, val|
-        break if n > 50
-        n+=1
-        true
-      }
-      assert_equal(51, n)
-      check_size(49, @gdbm)
-
-      @gdbm.clear
-
-      # raise
-      v = "0"
-      100.times {@gdbm[v] = v; v = v.next}
-      check_size(100, @gdbm)
-      n = 0;
-      begin
-        @gdbm.delete_if {|key, val|
-          raise "runtime error" if n > 50
-          n+=1
-          true
-        }
-      rescue
-      end
-      assert_equal(51, n)
-      check_size(49, @gdbm)
-    end
-
-    def test_reject
-      v = "0"
-      100.times {@gdbm[v] = v; v = v.next}
-
-      hash = @gdbm.reject {|key, val| key.to_i < 50}
-      assert_instance_of(Hash, hash)
-      assert_equal(100, @gdbm.size)
-
-      assert_equal(50, hash.size)
-      hash.each_pair {|key,val|
-        assert_equal(false, key.to_i < 50)
-        assert_equal(key, val)
-      }
-
-      hash = @gdbm.reject {|key, val| key.to_i < 100}
-      assert_instance_of(Hash, hash)
-      assert_equal(true, hash.empty?)
-    end
-
-    def test_clear
-      v = "1"
-      100.times {v = v.next; @gdbm[v] = v}
-
-      assert_equal(@gdbm, @gdbm.clear)
-
-      # validate GDBM#size
-      i = 0
-      @gdbm.each { i += 1 }
-      assert_equal(@gdbm.size, i)
-      assert_equal(0, i)
-    end
-
-    def test_invert
-      v = "0"
-      100.times {@gdbm[v] = v; v = v.next}
-
-      hash = @gdbm.invert
-      assert_instance_of(Hash, hash)
-      assert_equal(100, hash.size)
-      hash.each_pair {|key, val|
-        assert_equal(key.to_i, val.to_i)
-      }
-    end
-
-    def test_update
-      hash = {}
-      v = "0"
-      100.times {v = v.next; hash[v] = v}
-
-      @gdbm["101"] = "101"
-      @gdbm.update hash
-      assert_equal(101, @gdbm.size)
-      @gdbm.each_pair {|key, val|
-        assert_equal(key.to_i, val.to_i)
-      }
-    end
-
-    def test_replace
-      hash = {}
-      v = "0"
-      100.times {v = v.next; hash[v] = v}
-
-      @gdbm["101"] = "101"
-      @gdbm.replace hash
-      assert_equal(100, @gdbm.size)
-      @gdbm.each_pair {|key, val|
-        assert_equal(key.to_i, val.to_i)
-      }
-    end
-
-    def test_reorganize
-      size1 = File.size(@path)
-      i = "1"
-      1000.times {i = i.next; @gdbm[i] = i}
-      @gdbm.clear
-      @gdbm.sync
-
-      size2 = File.size(@path)
-      @gdbm.reorganize
-      size3 = File.size(@path)
-
-      # p [size1, size2, size3]
-      assert_equal(true, size1 < size2)
-      # this test is failed on Cygwin98. `GDBM version 1.8.0, as of May 19, 1999'
-      assert_equal(true, size3 < size2)
-      assert_equal(size1, size3)
-    end
-
-    def test_sync
-      assert_instance_of(GDBM, gdbm = GDBM.open('tmptest_gdbm', 0666, GDBM::FAST))
-      assert_equal(gdbm.sync, gdbm)
-      gdbm.close
-      assert_instance_of(GDBM, gdbm = GDBM.open('tmptest_gdbm', 0666))
-      assert_equal(gdbm.sync, gdbm)
-      gdbm.close
-    end
-
-    def test_cachesize=
-        assert_equal(@gdbm.cachesize = 1024, 1024)
-    end
-
-    def test_fastmode=
-        assert_equal(@gdbm.fastmode = true, true)
-    end
-
-    def test_syncmode=
-        assert_equal(@gdbm.syncmode = true, true)
-    end
-
-    def test_haskey?
-      assert_equal('bar', @gdbm['foo']='bar')
-      assert_equal(true,  @gdbm.has_key?('foo'))
-      assert_equal(false, @gdbm.has_key?('bar'))
-    end
-
-    def test_has_value?
-      assert_equal('bar', @gdbm['foo']='bar')
-      assert_equal(true,  @gdbm.has_value?('bar'))
-      assert_equal(false, @gdbm.has_value?('foo'))
-    end
-
-    def test_to_a
-      v = "0"
-      100.times {v = v.next; @gdbm[v] = v}
-
-      ary = @gdbm.to_a
-      assert_instance_of(Array, ary)
-      assert_equal(100, ary.size)
-      ary.each {|key,val|
-        assert_equal(key.to_i, val.to_i)
-      }
-    end
-
-    def test_to_hash
-      v = "0"
-      100.times {v = v.next; @gdbm[v] = v}
-
-      hash = @gdbm.to_hash
-      assert_instance_of(Hash, hash)
-      assert_equal(100, hash.size)
-      hash.each {|key,val|
-        assert_equal(key.to_i, val.to_i)
-      }
-    end
-  end
-
-  class TestGDBM2 < Test::Unit::TestCase
-    TMPROOT = "#{Dir.tmpdir}/ruby-gdbm.#{$$}"
-
-    def setup
-      Dir.mkdir TMPROOT
-    end
-
-    def teardown
-      FileUtils.rm_rf TMPROOT if File.directory?(TMPROOT)
-    end
-
-    def test_reader_open
-      GDBM.open("#{TMPROOT}/a.dbm") {}
-      v = GDBM.open("#{TMPROOT}/a.dbm", nil, GDBM::READER) {|d|
-        assert_raises(GDBMError) { d["k"] = "v" }
-        true
-      }
-      assert(v)
-    end
-
-    def test_newdb_open
-      GDBM.open("#{TMPROOT}/a.dbm") {|dbm|
-        dbm["k"] = "v"
-      } 
-      v = GDBM.open("#{TMPROOT}/a.dbm", nil, GDBM::NEWDB) {|d|
-        assert_equal(0, d.length)
-        assert_nil(d["k"])
-        true
-      }
-      assert(v)
-    end
-
-    def test_freeze
-      GDBM.open("#{TMPROOT}/a.dbm") {|d|
-        d.freeze
-        assert_raises(TypeError) { d["k"] = "v" }
-      }
-    end
-  end
-else
-  $stderr.puts "WARNING: Did not load gdbm library."
-end