bdb1 0.2.4

data/test/test_marshal.rb

@@ -0,0 +1,181 @@
+require 'helper'
+
+class TestMarshal < Test::Unit::TestCase
+  class AZ < BDB1::Btree
+    def bdb1_store_key(a)
+      "xx_" + a
+    end
+    def bdb1_fetch_key(a)
+      a.sub(/^xx_/, '')
+    end
+    def bdb1_store_value(a)
+      "yy_" + a
+    end
+    def bdb1_fetch_value(a)
+      a.sub(/^yy_/, '')
+    end
+  end
+
+  def test_00_error
+    clean_tmpdir
+    assert_raises(BDB1::Fatal, "invalid name") do
+      BDB1::Btree.new(".", "a")
+    end
+    assert_raises(BDB1::Fatal, "invalid Env") do
+      BDB1::Btree.open(tmpdir("aa"), "env" => 1)
+    end
+  end
+
+  def test_01_file
+    sub_file_init
+    sub_file_get_set
+    sub_file_delete
+    sub_file_cursor
+    sub_file_reopen
+    sub_file_dup
+    sub_file_close
+  end
+
+  def sub_file_init
+    assert_kind_of(BDB1::Btree, @bdb = BDB1::Btree.new(tmpdir("aa"), "a", "marshal" => Marshal), "<open>")
+  end
+
+  def sub_file_get_set
+    assert_equal([12, "alpha"], @bdb["alpha"] = [12, "alpha"], "<set value>")
+    assert_equal([12, "alpha"], @bdb["alpha"].to_orig, "<retrieve value>")
+    assert_equal(nil, @bdb["gamma"] = nil, "<set nil>")
+    assert_equal(nil, @bdb["gamma"].to_orig, "<retrieve nil>")
+    assert(@bdb.key?("alpha").to_orig == [12, "alpha"], "<has key>")
+    assert_equal(false, @bdb.key?("unknown"), "<has unknown key>")
+    assert(@bdb.value?(nil), "<has nil>")
+    assert(@bdb.value?([12, "alpha"]), "<has value>")
+    assert_equal(false, @bdb.value?("unknown"), "<has unknown value>")
+    assert_equal(false, @bdb.put("alpha", "gamma", BDB1::NOOVERWRITE), "<nooverwrite>")
+    assert_equal([12, "alpha"], @bdb["alpha"].to_orig, "<must not be changed>")
+    assert_equal([1, 2, [3, 4]], @bdb["array"] = [1, 2, [3, 4]], "<array>")
+    assert_equal([1, 2, [3, 4]], @bdb["array"].to_orig, "<retrieve array>")
+    assert_equal({"a" => "b"}, @bdb["hash"] = {"a" => "b"}, "<hash>")
+    assert_equal({"a" => "b"}, @bdb["hash"].to_orig, "<retrieve hash>")
+    assert(@bdb.sync, "<sync>")
+  end
+
+  def sub_file_delete
+    size = @bdb.size
+    i = 0
+    @bdb.each do |key, value|
+      assert_equal(@bdb, @bdb.delete(key), "<delete value>")
+      i += 1
+    end
+    assert(size == i, "<delete count>")
+    assert_equal(0, @bdb.size, "<empty>")
+  end
+
+  def sub_file_cursor
+    cat = Struct.new("Cat", :name, :age, :life)
+    array = ["abc", [1, 3], {"aa" => 12}, [2, {"bb" => "cc"}, 4],
+      cat.new("cat", 15, 7)]
+    array.each do |x|
+      assert_equal(x, @bdb[x] = x, "<set value>")
+    end
+    assert(array.size == @bdb.size, "<set count>")
+    @bdb.each_value do |x|
+      assert(array.index(x) != nil)
+    end
+    @bdb.reverse_each_value do |x|
+      assert(array.index(x) != nil)
+    end
+  end
+
+  def sub_file_reopen
+    assert_equal(nil, @bdb.close, "<close>")
+    assert_kind_of(BDB1::Btree, @bdb = BDB1::Btree.open(tmpdir("aa"), "w",
+	"set_flags" => BDB1::DUP, "marshal" => Marshal),
+      "<reopen with DB_DUP>")
+    assert_equal(0, @bdb.size, "<must be 0 after reopen>")
+  end
+
+  def sub_file_dup
+    array = [[[0, "a"], [1, "b"], [2, "c"], [3, "d"]],
+      [{"aa" => 0}, {"bb" => 1}, {"cc" => 2}],
+      [["aaa", 12], [12, "bbb"]],
+      ["aaaa"]]
+    ind = 0
+    array.each do |arr|
+      arr.each do |i|
+        assert_equal(i, @bdb[ind.to_s] = i, "<set dup>")
+      end
+      ind += 1
+    end
+  end
+
+  def sub_file_close
+    assert_equal(nil, @bdb.close, "<close>")
+  end
+
+  def test_02_memory
+    sub_memory_open
+    sub_memory_get_set
+    sub_memory_close
+  end
+
+  def sub_memory_open
+    assert_kind_of(BDB1::Btree, @bdb = BDB1::Btree.open("marshal" => Marshal), "<open in memory>")
+    assert_equal(0, @bdb.size, "<must be 0 after open>")
+  end
+
+  def sub_memory_get_set
+    assert_equal([1, 2, [3, 4]], @bdb["array"] = [1, 2, [3, 4]], "<set in memory>")
+    assert_equal([1, 2, [3, 4]], @bdb["array"].to_orig, "<get in memory>")
+    assert_equal({"a" => "b"}, @bdb["hash"] = {"a" => "b"}, "<set in memory>")
+    assert_equal({"a" => "b"}, @bdb["hash"].to_orig, "<get in memory>")
+    assert_equal("cc", @bdb["bb"] = "cc", "<set in memory>")
+    assert_equal("cc", @bdb["bb"].to_orig, "<get in memory>")
+  end
+
+  def sub_memory_close
+    assert_equal(nil, @bdb.close, "<close>")
+  end
+
+  def test_04_btree
+    sub_modify
+    sub_sh
+  end
+
+  def sub_modify
+    assert_kind_of(BDB1::Btree, @bdb = BDB1::Btree.open(tmpdir("aa"), "w",
+        "marshal" => Marshal),
+      "<reopen RECNUM>")
+    array = [1, "a", {"a" => 12}]
+    assert_equal(array, @bdb["a"] = array, "<set>")
+    arr = @bdb["a"]
+    arr.push [1, 2]; array.push [1, 2]
+    assert_equal(array, @bdb["a"].to_orig, "<get>")
+    @bdb["a"][-1] = 4; array[-1] = 4
+    assert_equal(array, @bdb["a"].to_orig, "<get>")
+    @bdb["a"][-1] = ["abc", 4]; array[-1] = ["abc", 4]
+    assert_equal(array, @bdb["a"].to_orig, "<get>")
+    assert_equal(nil, @bdb.close, "<close>")
+  end
+
+  def sub_sh
+    val = 'a' .. 'zz'
+    assert_equal(nil, @bdb.close, "<close>")
+    assert_kind_of(BDB1::Btree, @bdb = AZ.open(tmpdir("aa"), "w"), "<sh>")
+    val.each do |l|
+      assert_equal(l, @bdb[l] = l, "<store>")
+    end
+    @bdb.each do |k, v|
+      assert_equal(k, v, "<fetch>")
+    end
+    assert_equal(nil, @bdb.close, "<close>")
+    assert_kind_of(BDB1::Btree, @bdb = BDB1::Btree.open(tmpdir("aa")), "<sh>")
+    val.each do |l|
+      assert_equal("yy_#{l}", @bdb["xx_#{l}"], "<fetch value>")
+    end
+    @bdb.each do |k, v|
+      assert_equal("xx_", k[0, 3], "<fetch key>")
+      assert_equal("yy_", v[0, 3], "<fetch key>")
+    end
+    assert_equal(nil, @bdb.close, "<close>")
+  end
+end

data/test/test_recnum.rb

@@ -0,0 +1,440 @@
+require 'helper'
+
+class TestRecnum < Test::Unit::TestCase
+  def reinject(i)
+    1.upto(i) do |i|
+      @array.push i.to_s
+      @bdb1.push i
+    end
+  end
+
+  def test_00_error
+    clean_tmpdir
+    assert_raises(BDB1::Fatal, "invalid name") do
+      BDB1::Recnum.new(tmpdir("."), "a")
+    end
+    assert_raises(BDB1::Fatal, "invalid Env") do
+      BDB1::Recnum.open(tmpdir("aa"), "env" => 1)
+    end
+  end
+
+  def test_01
+    sub_init
+    sub_get_set
+    sub_subseq
+    sub_op
+    sub_at
+    sub_slice
+    sub_slice_bang
+    sub_reverse
+    sub_index
+    sub_delete
+    sub_reject
+    sub_clear
+    sub_fill
+    sub_include
+    sub_replace
+    sub_reopen
+    sub_collect
+    sub_insert
+    sub_flp
+    sub_cmp
+    sub_compact
+    sub_close
+  end
+
+  def sub_init
+    assert_kind_of(BDB1::Recnum, @bdb1 = BDB1::Recnum.new(tmpdir("aa"), "w"), "<open>")
+    @array = []
+  end
+
+  def sub_get_set
+    reinject(99)
+    @bdb1.each_index do |i|
+      assert_equal(@bdb1[i], @array[i], "<sequential get>")
+    end
+    -1.downto(-99) do |i|
+      assert_equal(@bdb1[i], @array[i], "<sequential get reversed>")
+    end
+    200.times do
+      i = rand(@array.size)
+      assert_equal(@bdb1[i], @array[i], "<random get>")
+    end
+  end
+
+  def sub_subseq
+    assert_equal(@bdb1[-1], @array[-1], "<negative index>")
+    assert_equal(@bdb1[2 .. 7], @array[2 .. 7], "<subseq>")
+    @bdb1[2 .. 7] = "a", "b"
+    @array[2 .. 7] = "a", "b"
+    assert_equal(@bdb1.size, @array.size, "<size>")
+    assert_equal(@bdb1.to_a, @array, "<small subseq>")
+    @bdb1[3 .. 6] = "a", "b", "c", "d", "e", "g", "h", "i"
+    @array[3 .. 6] = "a", "b", "c", "d", "e", "g", "h", "i"
+    assert_equal(@bdb1.size, @array.size, "<size>")
+    assert_equal(@bdb1.to_a, @array, "<big subseq>")
+  end
+
+  def sub_op
+    assert_equal(@bdb1 & ["1", "2", "3"], @array & ["1", "2", "3"], "<&>")
+    assert_equal(@bdb1 & [], @array & [], "<&>")
+    assert_equal(@bdb1 + ["3", "4"], @array + ["3", "4"], "<plus>")
+    assert_equal(["3", "4"] + @bdb1, ["3", "4"] + @array, "<plus>")
+    assert_equal(@bdb1 - ["3", "4"], @array - ["3", "4"], "<minus>")
+    assert_equal(["3", "4"] - @bdb1, ["3", "4"] - @array, "<minus>")
+    assert_equal(@bdb1 * 2, @array * 2, "<multiply>")
+    assert_equal(@bdb1 * ":", @array * ":", "<multiply>")
+    assert_equal(@bdb1 * "", @array * "", "<multiply>")
+    assert_equal(@bdb1.size, @array.size, "<size>")
+  end
+
+  def sub_at
+    assert_equal(@bdb1.to_a, @array, "<equal array>")
+    assert_equal(@bdb1.at(0), @array.at(0), "<positive at>")
+    assert_equal(@bdb1.at(10), @array.at(10), "<positive at>")
+    assert_equal(@bdb1.at(99), @array.at(99), "<positive at>")
+    assert_equal(@bdb1.at(205), @array.at(205), "<positive at>")
+    assert_equal(@bdb1.at(-1), @array.at(-1), "<negative at>")
+    assert_equal(@bdb1.at(-100), @array.at(-100), "<negative at>")
+    assert_equal(@bdb1.at(205), @array.at(205), "<negative at>")
+  end
+
+  def sub_slice
+    assert_equal(@bdb1.to_a, @array, "<equal array>")
+    100.times do
+      i = rand(@bdb1.size)
+      assert_equal(@bdb1.slice(i), @array.slice(i), "<slice>")
+    end
+    100.times do
+      i = rand(@bdb1.size)
+      assert_equal(@bdb1.slice(-i), @array.slice(-i), "<negative slice>")
+    end
+    100.times do
+      i = rand(@bdb1.size)
+      j = rand(@bdb1.size)
+      assert_equal(@bdb1.slice(i, j), @array.slice(i, j), "<slice>")
+    end
+    100.times do
+      i = rand(@bdb1.size)
+      j = rand(@bdb1.size)
+      assert_equal(@bdb1.slice(-i, j), @array.slice(-i, j), "<negative slice>")
+    end
+    100.times do
+      i = rand(@bdb1.size)
+      j = rand(@bdb1.size)
+      assert_equal(@bdb1.slice(i .. j), @array.slice(i .. j), "<range>")
+    end
+    100.times do
+      i = rand(@bdb1.size)
+      j = rand(@bdb1.size)
+      assert_equal(@bdb1.slice(-i, j), @array.slice(-i, j), "<negative range>")
+    end
+  end
+
+  def sub_slice_bang
+    assert_equal(@bdb1.to_a, @array, "<equal array>")
+    10.times do |iter|
+      i = rand(@bdb1.size)
+      assert_equal(@bdb1.slice!(i), @array.slice!(i), "<#{iter} slice!(#{i})>")
+      assert_equal(@bdb1.size, @array.size, "<size after slice!(#{i})  #{iter}>")
+      reinject(60) if @bdb1.size < 20
+    end
+    10.times do |iter|
+      i = rand(@bdb1.size)
+      assert_equal(@bdb1.slice!(-i), @array.slice!(-i), "<slice!(#{-i})>")
+      assert_equal(@bdb1.size, @array.size, "<size after slice!(#{-i}) #{iter}>")
+      reinject(60) if @bdb1.size < 20
+    end
+    10.times do  |iter|
+      i = rand(@bdb1.size)
+      j = rand(@bdb1.size)
+      assert_equal(@bdb1.slice!(i, j), @array.slice!(i, j), "<slice!(#{i}, #{j})>")
+      assert_equal(@bdb1.size, @array.size, "<size after slice!(#{i}, #{j}) #{iter}>")
+      reinject(60) if @bdb1.size < 20
+    end
+    10.times do |iter|
+      i = rand(@bdb1.size)
+      j = i + rand(@bdb1.size - i)
+      assert_equal(@bdb1.slice!(-i, j), @array.slice!(-i, j), "<slice!(#{-i}, #{j})>")
+      assert_equal(@bdb1.size, @array.size, "<size after slice!(#{-i}, #{j}) #{iter}>")
+      reinject(60) if @bdb1.size < 20
+    end
+    reinject(60)
+    another = 0
+    10.times do |iter|
+      i = rand(@bdb1.size)
+      j = i + rand(@bdb1.size - i)
+      if ! @array.slice(i .. j)
+        assert_raises(RangeError, "<invalid range>") { @bdb1.slice!(i .. j) }
+        another += 1
+        redo if another < 10
+        another = 0
+        next
+      end
+      assert_equal(@bdb1.slice!(i .. j), @array.slice!(i .. j), "<slice!(#{i} .. #{j})>")
+      assert_equal(@bdb1.size, @array.size, "<size after slice! #{iter}>")
+      another = 0
+      reinject(60) if @bdb1.size < 20
+    end
+    another = 0
+    10.times do |iter|
+      i = rand(@bdb1.size)
+      j = 1 + rand(@bdb1.size - i)
+      if ! @array.slice(-i .. -j)
+        assert_raises(RangeError, "<invalid range>") { @bdb1.slice!(-i .. -j) }
+        another += 1
+        redo if another < 10
+        another = 0
+        next
+      end
+      assert_equal(@bdb1.slice!(-i .. -j), @array.slice!(-i .. -j), "<slice!(#{-i} .. #{-j})>")
+      assert_equal(@bdb1.size, @array.size, "<size after slice! #{iter}>")
+      another = 0
+      reinject(60) if @bdb1.size < 20
+    end
+    reinject(40) if @bdb1.size < 40
+    assert_equal(@bdb1.size, @array.size, "<size end slice!>")
+    assert_equal(@bdb1.to_a, @array, "<size end slice!>")
+  end
+
+  def sub_reverse
+    assert_equal(@bdb1.reverse, @array.reverse, "<reverse>")
+    @array.reverse! ; @bdb1.reverse!
+    assert_equal(@bdb1.to_a, @array, "<reverse bang>")
+    assert_equal(@bdb1.size, @array.size, "<size after reverse>")
+  end
+
+  def sub_index
+    100.times do
+      i = rand(@bdb1.size)
+      assert_equal(@bdb1.index(i), @array.index(i), "<index #{i}>")
+      assert_equal(@bdb1.index(-i), @array.index(-i), "<negative index #{i}>")
+    end
+    100.times do
+      i = rand(@bdb1.size)
+      assert_equal(@bdb1.rindex(i), @array.rindex(i), "<rindex #{i}>")
+      assert_equal(@bdb1.rindex(-i), @array.rindex(-i), "<negative rindex #{i}>")
+    end
+    100.times do
+      aa = []
+      rand(12).times do
+        aa.push(rand(@bdb1.size))
+      end
+      assert_equal(@array.values_at(*aa), @bdb1.values_at(*aa), "<values_at>")
+    end
+    100.times do
+      aa = []
+      rand(12).times do
+        aa.push(-1 * rand(@bdb1.size))
+      end
+      assert_equal(@array.values_at(*aa), @bdb1.values_at(*aa), "<negative values_at #{aa}>")
+    end
+  end
+
+  def sub_delete
+    assert_equal(@bdb1.to_a, @array, "<before delete>")
+    100.times do
+      i = rand(@bdb1.size)
+      assert_equal(@bdb1.delete(i), @array.delete(i), "<delete #{i}>")
+      reinject(60) if @bdb1.size < 20
+    end
+    assert_equal(@bdb1.to_a, @array, "<after delete>")
+    100.times do
+      i = rand(@bdb1.size)
+      assert_equal(@bdb1.delete_at(i), @array.delete_at(i), "<delete at #{i}>")
+      reinject(60) if @bdb1.size < 20
+    end
+    assert_equal(@bdb1.to_a, @array, "<after delete_at>")
+    reinject(60) if @bdb1.size < 60
+    assert_equal(@bdb1.delete_if { false }, @bdb1, "<delete_if false>")
+    assert_equal(@bdb1.to_a, @array, "<after delete_if false>")
+    assert_equal(@bdb1.delete_if { true }, @bdb1, "<delete_if true>")
+    assert_equal(@bdb1.size, 0, "<after delete_if true>")
+    @bdb1.push *@array
+    assert_equal(@bdb1.to_a, @array, "<after push>")
+    100.times do
+      i = rand(@bdb1.size)
+      assert_equal(@bdb1.delete_if {|i| i.to_i > 32}, @bdb1, "<delete_if condition>")
+      @array.delete_if {|i| i.to_i > 32}
+      assert_equal(@bdb1.to_a, @array, "<delete_if condition compare>")
+      reinject(60) if @bdb1.size < 60
+    end
+    reinject(99) if @bdb1.size < 99
+  end
+
+  def sub_reject
+    assert_equal(@bdb1.to_a, @array, "<before reject!>")
+    assert_equal(nil, @bdb1.reject! { false }, "<reject! false>")
+  end
+
+  def sub_clear
+    @bdb1.clear ; @array.clear
+    assert_equal(@array.size, @bdb1.size, "<size after clear>")
+    assert_equal(@array, @bdb1.to_a, "<after clear>")
+  end
+
+  def sub_fill
+    @bdb1.fill "32", 0, 99; @array.fill "32", 0, 99
+    assert_equal(@array.size, @bdb1.size, "<size after fill>")
+    assert_equal(@array, @bdb1.to_a, "<after fill>")
+    @bdb1.fill "42"; @array.fill "42"
+    assert_equal(@array.size, @bdb1.size, "<size after fill>")
+    assert_equal(@array, @bdb1.to_a, "<after fill>")
+    10.times do |iter|
+      k = rand(@bdb1.size).to_s
+      i = rand(@bdb1.size)
+      assert_equal(@bdb1.fill(k, i).to_a, @array.fill(k, i), "<#{iter} fill(#{i})>")
+      assert_equal(@bdb1.size, @array.size, "<size after fill(#{i})  #{iter}>")
+      reinject(60) if @bdb1.size < 20
+    end
+    10.times do |iter|
+      k = rand(@bdb1.size).to_s
+      i = rand(@bdb1.size)
+      assert_equal(@bdb1.fill(k, -i).to_a, @array.fill(k, -i), "<fill(#{-i})>")
+      assert_equal(@bdb1.size, @array.size, "<size after fill(#{-i}) #{iter}>")
+      reinject(60) if @bdb1.size < 20
+    end
+    10.times do  |iter|
+      k = rand(@bdb1.size).to_s
+      i = rand(@bdb1.size)
+      j = rand(@bdb1.size)
+      assert_equal(@bdb1.fill(k, i, j).to_a, @array.fill(k, i, j), "<fill(#{i}, #{j})>")
+      assert_equal(@bdb1.size, @array.size, "<size after fill(#{i}, #{j}) #{iter}>")
+      reinject(60) if @bdb1.size < 20
+    end
+    10.times do |iter|
+      k = rand(@bdb1.size).to_s
+      i = rand(@bdb1.size)
+      j = i + rand(@bdb1.size - i)
+      assert_equal(@bdb1.fill(k, -i, j).to_a, @array.fill(k, -i, j), "<fill(#{-i}, #{j})>")
+      assert_equal(@bdb1.size, @array.size, "<size after fill(#{-i}, #{j}) #{iter}>")
+      reinject(60) if @bdb1.size < 20
+    end
+    reinject(60)
+    another = 0
+    10.times do |iter|
+      k = rand(@bdb1.size).to_s
+      i = rand(@bdb1.size)
+      j = i + rand(@bdb1.size - i)
+      if ! @array.slice(i .. j)
+        assert_raises(RangeError, "<invalid range>") { @bdb1.fill(k, i .. j) }
+        another += 1
+        redo if another < 10
+        another = 0
+        next
+      end
+      assert_equal(@bdb1.fill(k, i .. j).to_a, @array.fill(k, i .. j), "<fill(#{i} .. #{j})>")
+      assert_equal(@bdb1.size, @array.size, "<size after fill #{iter}>")
+      another = 0
+      reinject(60) if @bdb1.size < 20
+    end
+    another = 0
+    10.times do |iter|
+      k = rand(@bdb1.size).to_s
+      i = rand(@bdb1.size)
+      j = 1 + rand(@bdb1.size - i)
+      if ! @array.slice(-i .. -j)
+        assert_raises(RangeError, "<invalid range>") { @bdb1.fill(k, -i .. -j) }
+        another += 1
+        redo if another < 10
+        another = 0
+        next
+      end
+      assert_equal(@bdb1.fill(k, -i .. -j).to_a, @array.fill(k, -i .. -j), "<fill(#{-i} .. #{-j})>")
+      assert_equal(@bdb1.size, @array.size, "<size after fill #{iter}>")
+      another = 0
+      reinject(60) if @bdb1.size < 20
+    end
+    reinject(60) if @bdb1.size < 60
+    assert_equal(@bdb1.size, @array.size, "<size end fill>")
+    assert_equal(@bdb1.to_a, @array, "<size end fill>")
+  end
+
+  def sub_include
+    @bdb1.clear; @array.clear; reinject(99)
+    assert_equal(@bdb1.size, @array.size, "<size end clear>")
+    assert_equal(@bdb1.to_a, @array, "<size end clear>")
+    100.times do
+      k = rand(@bdb1.size + 20).to_s
+      assert_equal(@array.include?(k), @bdb1.include?(k), "<include(#{k})>")
+    end
+  end
+
+  def sub_replace
+    @array.replace(('a' .. 'zz').to_a)
+    @bdb1.replace(('a' .. 'zz').to_a)
+    assert_equal(@bdb1.size, @array.size, "<size end fill>")
+    assert_equal(@bdb1.to_a, @array, "<size end fill>")
+  end
+
+  def sub_reopen
+    @bdb1.close
+    assert_kind_of(BDB1::Recnum, @bdb1 = BDB1::Recnum.new(tmpdir("aa"), "a"), "<open>")
+    assert_equal(@bdb1.size, @array.size, "<size end reopen>")
+    assert_equal(@bdb1.to_a, @array, "<size end open>")
+  end
+
+  def sub_collect
+    a = @bdb1.collect
+    assert_equal(@array, a, "<collect>")
+    a = @array.collect {|k| k + "!"}
+    b = @bdb1.collect {|k| k + "!"}
+    assert_equal(a, b, "<collect>")
+    assert_equal(@bdb1.to_a, @array, "<collect bdb>")
+
+    a = @array.collect! {|k| k + "!"}
+    b = @bdb1.collect! {|k| k + "!"}
+    assert_equal(a, b, "<collect!>")
+    assert_equal(@bdb1.to_a, @array, "<collect bdb>")
+  end
+
+  def sub_insert
+    @array.insert(2, "1", "2", "3")
+    @array.insert(-1, "4", "5")
+    @array.insert(-4, "3", "5", "5", "5", "5")
+    @bdb1.insert(2, 1, 2, 3)
+    @bdb1.insert(-1, 4, 5)
+    @bdb1.insert(-4, 3, 5, 5, 5, 5)
+    assert_equal(@bdb1.to_a, @array, "<insert bdb>")
+  end
+
+  def sub_flp
+    assert_equal(@array.first, @bdb1.first, "<first>")
+    assert_equal(@array.last, @bdb1.last, "<last>")
+    @bdb1.concat(@array)
+    @array.concat(@array)
+    assert_equal(@bdb1.to_a, @array, "<insert bdb>")
+    assert_equal(@bdb1, @bdb1 << 12, "<push>")
+    @array << "12"
+    assert_equal(@bdb1.to_a, @array, "<insert bdb>")
+    assert_equal(@array.pop, @bdb1.pop, "<pop>")
+    @array.unshift("5", "6")
+    @bdb1.unshift(5, 6)
+    assert_equal(@bdb1.to_a, @array, "<unshift bdb>")
+    assert_equal(@array.shift, @bdb1.shift, "<shift>")
+    assert_equal(@bdb1.to_a, @array, "<unshift bdb>")
+    assert_equal(0, @bdb1 <=> @array, "<cmp>")
+  end
+
+  def sub_cmp
+    assert_kind_of(BDB1::Recnum, bdb1 = BDB1::Recnum.new(tmpdir("bb"), "a"), "<open>")
+    assert_equal(true, bdb1.empty?, "<empty>")
+    @array.each {|a| bdb1 << a}
+    assert_equal(false, bdb1.empty?, "<empty>")
+    assert_equal(0, @bdb1 <=> bdb1, "<=>")
+    bdb1 << 12
+    assert_equal(1, bdb1 <=> @bdb1, "<=>")
+    assert_equal(-1, @bdb1 <=> bdb1, "<=>")
+  end
+
+  def sub_compact
+    assert_equal(@array.compact, @bdb1.compact, "<compact>")
+    @array.compact!
+    @bdb1.compact!
+    assert_equal(@bdb1.to_a, @array, "<compact!>")
+  end
+
+  def sub_close
+    assert_equal(nil, @bdb1.close, "<close>")
+  end
+end