oklahoma_mixer 0.1.0 → 0.2.0

data/test/b_tree_binary_data_test.rb

@@ -0,0 +1,45 @@
+require "test_helper"
+require "shared_binary_data"
+
+class TestBTreeBinaryData < Test::Unit::TestCase
+  def setup
+    @db       = bdb
+    @key      = "Binary\0Name"
+    @value    = "James\0Edward\0Gray\0II"
+    @db[@key] = @value
+    @closed   = false
+  end
+  
+  def teardown
+    @db.close unless @closed
+    remove_db_files
+  end
+  
+  include SharedBinaryData
+
+  def test_null_bytes_are_preserved_during_value_iteration
+    @db.each_value do |value|
+      assert_equal(@value, value)
+    end
+  end
+  
+  def test_null_bytes_are_preserved_by_key_ranges
+    assert_equal([@key], @db.keys(:range => "A".."Z"))
+  end
+  
+  def test_null_bytes_are_preserved_in_comparison_functions
+    @db.close
+    @closed = true
+    remove_db_files
+    
+    callback = lambda { |a, b|
+      assert_equal(@key, a) unless a.empty?
+      assert_equal(@key, b) unless b.empty?
+      a <=> b
+    }
+    bdb(:cmpfunc => callback) do |db|
+      db[@key] = @value
+      assert_equal([@key], db.keys)  # forces a comparison with ""
+    end
+  end
+end

data/test/b_tree_tuning_test.rb

@@ -0,0 +1,132 @@
+require "test_helper"
+require "shared_tuning"
+
+class TestBTreeTuning < Test::Unit::TestCase
+  def teardown
+    remove_db_files
+  end
+  
+  include SharedTuning
+  
+  def test_leaf_members_can_be_set_with_other_tuning_defaults
+    members = rand(1_000) + 1
+    assert_option_calls([:tune, members, 0, 0, -1, -1, 0xFF], :lmemb => members)
+  end
+  
+  def test_leaf_members_is_converted_to_an_int
+    assert_option_calls([:tune, 42, 0, 0, -1, -1, 0xFF], :lmemb => "42")
+  end
+  
+  def test_non_leaf_members_can_be_set_with_other_tuning_defaults
+    members = rand(1_000) + 1
+    assert_option_calls([:tune, 0, members, 0, -1, -1, 0xFF], :nmemb => members)
+  end
+  
+  def test_non_leaf_members_is_converted_to_an_int
+    assert_option_calls([:tune, 0, 42, 0, -1, -1, 0xFF], :nmemb => "42")
+  end
+  
+  def test_a_bucket_array_size_can_be_set_with_other_tuning_defaults
+    size = rand(1_000) + 1
+    assert_option_calls([:tune, 0, 0, size, -1, -1, 0xFF], :bnum => size)
+  end
+  
+  def test_bucket_array_size_is_converted_to_an_int
+    assert_option_calls([:tune, 0, 0, 42, -1, -1, 0xFF], :bnum => "42")
+  end
+  
+  def test_a_record_alignment_power_can_be_set_with_other_tuning_defaults
+    pow = rand(10) + 1
+    assert_option_calls([:tune, 0, 0, 0, pow, -1, 0xFF], :apow => pow)
+  end
+  
+  def test_record_alignment_power_is_converted_to_an_int
+    assert_option_calls([:tune, 0, 0, 0, 42, -1, 0xFF], :apow => "42")
+  end
+  
+  def test_a_max_free_block_power_can_be_set_with_other_tuning_defaults
+    pow = rand(10) + 1
+    assert_option_calls([:tune, 0, 0, 0, -1, pow, 0xFF], :fpow => pow)
+  end
+  
+  def test_max_free_block_power_is_converted_to_an_int
+    assert_option_calls([:tune, 0, 0, 0, -1, 42, 0xFF], :fpow => "42")
+  end
+  
+  def test_options_can_be_set_with_other_tuning_defaults
+    assert_option_calls([:tune, 0, 0, 0, -1, -1, 1 | 2], :opts => "ld")
+  end
+  
+  def test_options_is_a_string_of_characters_mapped_to_enums_and_ored_together
+    opts = {"l" => lib::OPTS[:BDBTLARGE], "b" => lib::OPTS[:BDBTBZIP]}
+    assert_option_calls( [ :tune, 0, 0, 0, -1, -1,
+                           opts.values.inject(0) { |o, v| o | v } ],
+                         :opts => opts.keys.join )
+  end
+  
+  def test_the_options_string_is_not_case_sensative
+    assert_option_calls([:tune, 0, 0, 0, -1, -1, 1 | 2], :opts => "ld")
+    assert_option_calls([:tune, 0, 0, 0, -1, -1, 1 | 2], :opts => "LD")
+  end
+  
+  def test_unknown_options_are_ignored_with_a_warning
+    warning = capture_stderr do
+      assert_option_calls([:tune, 0, 0, 0, -1, -1, 1 | 8], :opts => "ltu")
+    end
+    assert(!warning.empty?, "A warning was not issued for an unknown option")
+  end
+  
+  def test_multiple_tuning_parameters_can_be_set_at_the_same_time
+    members = rand(1_000) + 1
+    size    = rand(1_000) + 1
+    assert_option_calls( [:tune, members, 0, size, -1, -1, 1 | 2],
+                         :lmemb => members, :bnum => size, :opts => "ld" )
+  end
+  
+  def test_optimize_allows_the_adjustment_of_tune_options_for_an_open_database
+    db do |db|
+      args = capture_args(lib, :optimize) do
+        db.optimize(:apow => "42", :opts => "ld")
+      end
+      assert_instance_of(FFI::Pointer, args[0])
+      assert_equal([0, 0, 0, 42, -1, 1 | 2], args[1..-1])
+    end
+  end
+
+  def test_leaf_nodes_cached_can_be_set_with_other_cache_defaults
+    nodes = rand(1_000) + 1
+    assert_option_calls([:setcache, nodes, 0], :lcnum => nodes)
+  end
+
+  def test_leaf_nodes_cached_is_converted_to_an_int
+    assert_option_calls([:setcache, 42, 0], :lcnum => "42")
+  end
+
+  def test_non_leaf_nodes_cached_can_be_set_with_other_cache_defaults
+    nodes = rand(1_000) + 1
+    assert_option_calls([:setcache, 0, nodes], :ncnum => nodes)
+  end
+
+  def test_non_leaf_nodes_cached_is_converted_to_an_int
+    assert_option_calls([:setcache, 0, 42], :ncnum => "42")
+  end
+  
+  def test_multiple_cache_parameters_can_be_set_at_the_same_time
+    l_nodes = rand(1_000) + 1
+    n_nodes = rand(1_000) + 1
+    assert_option_calls( [:setcache, l_nodes, n_nodes],
+                         :lcnum => l_nodes, :ncnum => n_nodes )
+  end
+  
+  #######
+  private
+  #######
+  
+  def lib
+    OKMixer::BTreeDatabase::C
+  end
+  
+  def db(*args, &block)
+    bdb(*args, &block)
+  end
+end

data/test/binary_data_test.rb

@@ -1,4 +1,5 @@
 require "test_helper"
+require "shared_binary_data"
 
 class TestBinaryData < Test::Unit::TestCase
   def setup
@@ -13,6 +14,8 @@ class TestBinaryData < Test::Unit::TestCase
     remove_db_files
   end
   
+  include SharedBinaryData
+  
   def test_keys_and_values_can_be_read_with_null_bytes
     assert_equal(@value, @db[@key])
   end
@@ -22,19 +25,6 @@ class TestBinaryData < Test::Unit::TestCase
     assert_equal("new\0value", @db[@key])
   end
   
-  def test_null_bytes_are_preserved_during_key_iteration
-    @db.each_key do |key|
-      assert_equal(@key, key)
-    end
-  end
-  
-  def test_null_bytes_are_preserved_during_iteration
-    @db.each do |key, value|
-      assert_equal(@key,   key)
-      assert_equal(@value, value)
-    end
-  end
-  
   def test_null_bytes_are_preserved_by_key_listing
     assert_equal([@key], @db.keys)
   end

data/test/cursor_based_iteration_test.rb

@@ -0,0 +1,151 @@
+require "test_helper"
+require "shared_iteration"
+
+class TestCursorBasedIteration < Test::Unit::TestCase
+  def setup
+    @db     = bdb
+    @keys   = %w[a b c]
+    @values = @keys.map { |key| key * 2 }
+    @keys.zip(@values) do |key, value|
+      @db[key] = value
+    end
+  end
+  
+  def teardown
+    @db.close
+    remove_db_files
+  end
+  
+  include SharedIteration
+  
+  def test_each_key_can_begin_iteration_at_a_passed_key
+    @db.each_key("b") do |key|
+      @keys.delete(key)
+    end
+    assert_equal(%w[a], @keys)
+  end
+  
+  def test_each_key_can_begin_iteration_between_keys
+    @db.each_key("ab") do |key|  # after "a", but before "b"
+      @keys.delete(key)
+    end
+    assert_equal(%w[a], @keys)
+  end
+  
+  def test_iteration_can_be_broken_with_each_key
+    @db.each_key("b") do |key|
+      @keys.delete(key)
+      break
+    end
+    assert_equal(%w[a c], @keys)
+  end
+  
+  def test_each_can_begin_iteration_at_a_passed_key
+    @db.each("b") do |key, value|
+      @keys.delete(key)
+      @values.delete(value)
+    end
+    assert_equal(%w[a],  @keys)
+    assert_equal(%w[aa], @values)
+  end
+  
+  def test_each_can_begin_iteration_between_keys
+    @db.each("ab") do |key, value|  # after "a", but before "b"
+      @keys.delete(key)
+      @values.delete(value)
+    end
+    assert_equal(%w[a],  @keys)
+    assert_equal(%w[aa], @values)
+  end
+  
+  def test_iteration_can_be_broken_with_each
+    @db.each("b") do |key, value|
+      @keys.delete(key)
+      @values.delete(value)
+      break
+    end
+    assert_equal(%w[a  c],  @keys)
+    assert_equal(%w[aa cc], @values)
+  end
+
+  def test_reverse_each_can_begin_iteration_at_a_passed_key
+    @db.reverse_each("b") do |key, value|
+      @keys.delete(key)
+      @values.delete(value)
+    end
+    assert_equal(%w[c],  @keys)
+    assert_equal(%w[cc], @values)
+  end
+  
+  def test_reverse_each_can_begin_iteration_between_keys
+    @db.reverse_each("ab") do |key, value|  # after "a", but before "b"
+      @keys.delete(key)
+      @values.delete(value)
+    end
+    assert_equal(%w[c],  @keys)
+    assert_equal(%w[cc], @values)
+  end
+  
+  def test_iteration_can_be_broken_with_reverse_each
+    @db.reverse_each("b") do |key, value|
+      @keys.delete(key)
+      @values.delete(value)
+      break
+    end
+    assert_equal(%w[a  c],  @keys)
+    assert_equal(%w[aa cc], @values)
+  end
+  
+  def test_each_value_can_begin_iteration_at_a_passed_key
+    @db.each_value("b") do |value|
+      @values.delete(value)
+    end
+    assert_equal(%w[aa], @values)
+  end
+  
+  def test_each_value_can_begin_iteration_between_keys
+    @db.each_value("ab") do |value|  # after "a", but before "b"
+      @values.delete(value)
+    end
+    assert_equal(%w[aa], @values)
+  end
+  
+  def test_iteration_can_be_broken_with_each_value
+    @db.each_value("b") do |value|
+      @values.delete(value)
+      break
+    end
+    assert_equal(%w[aa cc], @values)
+  end
+  
+  def test_delete_if_can_begin_iteration_at_a_passed_key
+    @db.delete_if("b") do |key, value|
+      @keys.delete(key)
+      @values.delete(value)
+      true
+    end
+    assert_equal(%w[a],  @keys)
+    assert_equal(%w[aa], @values)
+  end
+  
+  def test_delete_if_can_begin_iteration_between_keys
+    @db.delete_if("ab") do |key, value|  # after "a", but before "b"
+      @keys.delete(key)
+      @values.delete(value)
+      true
+    end
+    assert_equal(%w[a],  @keys)
+    assert_equal(%w[aa], @values)
+  end
+  
+  def test_iteration_can_be_broken_with_each_delete_if
+    @db.delete_if("b") do |key, value|
+      break if key == "c"
+      @keys.delete(key)
+      @values.delete(value)
+      true
+    end
+    assert_equal(%w[a  c],  @keys)
+    assert_equal(%w[aa cc], @values)
+  end
+end

data/test/duplicate_storage_test.rb

@@ -0,0 +1,107 @@
+require "test_helper"
+
+class TestDuplicateStorage < Test::Unit::TestCase
+  def setup
+    @db = bdb
+  end
+  
+  def teardown
+    @db.close
+    remove_db_files
+  end
+  
+  def test_duplicates_can_be_stored
+    assert(@db.store("Gray", "Dana",  :dup), "Failed to store initial value")
+    assert(@db.store("Gray", "James", :dup), "Failed to store duplicate value")
+    assert_equal("Dana", @db["Gray"])  # always returns the first
+  end
+  
+  def test_keys_are_a_unique_listing_not_showing_duplicates
+    @db.update("Gray" => "Dana", "Matsumoto" => "Yukihiro")
+    @db.store("Gray", "James", :dup)
+    assert_equal(%w[Gray Matsumoto], @db.keys)
+    assert_equal(%w[Gray],           @db.keys(:range => "G"..."H"))
+  end
+  
+  def test_values_can_be_scoped_to_a_key_to_retrieve_all_duplicates
+    @db[:other] = "one record"
+    assert_equal(["one record"], @db.values)
+    assert_equal([ ],            @db.values("Gray"))
+    assert(@db.store("Gray", "Dana", :dup), "Failed to store initial value")
+    assert_equal(%w[Dana], @db.values("Gray"))
+    assert(@db.store("Gray", "James", :dup), "Failed to store duplicate value")
+    assert_equal(%w[Dana James], @db.values("Gray"))
+  end
+  
+  def test_delete_removes_the_first_value_by_default
+    @db.update("Gray" => "Dana", "Matsumoto" => "Yukihiro")
+    @db.store("Gray", "James", :dup)
+    assert_equal(%w[Dana James], @db.values("Gray"))
+    assert_equal("Dana",         @db.delete("Gray"))
+    assert_equal(%w[James],      @db.values("Gray"))
+    assert_equal("James",        @db.delete("Gray"))
+    assert_nil(@db.delete("Gray"))
+  end
+  
+  def test_delete_with_dup_mode_deletes_all_values
+    @db.update("Gray" => "Dana", "Matsumoto" => "Yukihiro")
+    @db.store("Gray", "James", :dup)
+    assert_equal(%w[Dana James], @db.values("Gray"))
+    assert_equal(%w[Dana James], @db.delete("Gray", :dup))
+    assert_equal([ ],            @db.delete("Gray", :dup))
+  end
+  
+  def test_delete_with_dup_mode_supports_the_missing_handler
+    assert_nil(@db.delete(:missing, :dup) { nil })
+  end
+  
+  def test_size_can_be_scoped_to_a_key_to_retrieve_all_duplicates
+    @db[:other] = "one record"
+    assert_equal(1, @db.size)
+    assert_equal(0, @db.size("Gray"))
+    assert(@db.store("Gray", "Dana", :dup), "Failed to store initial value")
+    assert_equal(1, @db.size("Gray"))
+    assert(@db.store("Gray", "James", :dup), "Failed to store duplicate value")
+    assert_equal(2, @db.size("Gray"))
+  end
+  
+  def test_duplicates_show_up_in_cursor_based_iteration_of_keys
+    @db.update("Gray" => "Dana", "Matsumoto" => "Yukihiro")
+    @db.store("Gray", "James", :dup)
+    keys = [ ]
+    @db.each_key do |key|
+      keys << key
+    end
+    assert_equal(%w[Gray Gray Matsumoto], keys)
+  end
+  
+  def test_duplicates_show_up_in_cursor_based_iteration
+    @db.update("Gray" => "Dana", "Matsumoto" => "Yukihiro")
+    @db.store("Gray", "James", :dup)
+    pairs = [ ]
+    @db.each do |pair|
+      pairs << pair
+    end
+    assert_equal([%w[Gray Dana], %w[Gray James], %w[Matsumoto Yukihiro]], pairs)
+  end
+  
+  def test_duplicates_show_up_in_reverse_cursor_based_iteration
+    @db.update("Gray" => "Dana", "Matsumoto" => "Yukihiro")
+    @db.store("Gray", "James", :dup)
+    pairs = [ ]
+    @db.reverse_each do |pair|
+      pairs << pair
+    end
+    assert_equal([%w[Matsumoto Yukihiro], %w[Gray James], %w[Gray Dana]], pairs)
+  end
+  
+  def test_duplicates_show_up_in_cursor_based_iteration_of_values
+    @db.update("Gray" => "Dana", "Matsumoto" => "Yukihiro")
+    @db.store("Gray", "James", :dup)
+    values = [ ]
+    @db.each_value do |value|
+      values << value
+    end
+    assert_equal(%w[Dana James Yukihiro], values)
+  end
+end