perobs 3.0.1 → 4.3.0

data/test/BigHash_spec.rb

@@ -0,0 +1,152 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2017, 2019 by Chris Schlaeger <chris@taskjuggler.org>
+#
+# This file contains tests for Hash that are similar to the tests for the
+# Hash implementation in MRI. The ideas of these tests were replicated in
+# this code.
+#
+# MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'spec_helper'
+
+require 'perobs'
+require 'perobs/BigHash'
+
+class PEROBS::BigHash
+
+  # Redefine the hash method to make collisions very likely. This will help to
+  # test the collision handling with small amounts of data.
+  #def hash_key(key)
+  #  key.hash & 0xF
+  #end
+
+end
+
+ENTRIES = 200
+
+describe PEROBS::Hash do
+
+  before(:all) do
+    @db_name = generate_db_name(__FILE__)
+  end
+
+  before(:each) do
+    @store = PEROBS::Store.new(@db_name)
+    @h = @store.new(PEROBS::BigHash)
+    @store['hash'] = @h
+  end
+
+  after(:each) do
+    @store.delete_store
+  end
+
+  it 'should support storing and retrieving an object' do
+    expect(@h.check).to be true
+    expect(@h.length).to eql(0)
+    expect(@h.empty?).to be true
+    expect(@h.keys).to eql([])
+    @h['foo'] = 'bar'
+    expect(@h.check).to be true
+    expect(@h['foo']).to eql('bar')
+    expect(@h.length).to eql(1)
+    expect(@h.keys).to eql([ 'foo' ])
+  end
+
+  it 'should store a few objects' do
+    20.times do |i|
+      @h["bar#{i}"] = "foo#{i}"
+    end
+    expect(@h.size).to eql(20)
+  end
+
+  it 'should return nil for unknown objects' do
+    expect(@h['bar']).to be_nil
+  end
+
+  it 'should be able to store values with hash collisions' do
+    ENTRIES.times do |i|
+      @h["key#{i}"] = i
+    end
+    expect(@h.check).to be true
+    expect(@h.length).to eql(ENTRIES)
+
+    ENTRIES.times do |i|
+      expect(@h["key#{i}"]).to eql(i)
+    end
+  end
+
+  it 'should replace existing entries' do
+    ENTRIES.times do |i|
+      @h["key#{i}"] = 2 * i
+    end
+    expect(@h.check).to be true
+    expect(@h.length).to eql(ENTRIES)
+
+    ENTRIES.times do |i|
+      expect(@h["key#{i}"]).to eql(2 * i)
+    end
+    expect(@h.length).to eql(ENTRIES)
+  end
+
+  it 'should fail to delete a non-existing entry' do
+    expect(@h.delete('foo')).to be_nil
+    expect(@h.check).to be true
+  end
+
+  it 'should delete existing entries' do
+    (1..ENTRIES).to_a.shuffle.each do |i|
+      @h["key#{i}"] = 2 * i
+    end
+    expect(@h.check).to be true
+    expect(@h.length).to eql(ENTRIES)
+    (1..ENTRIES).to_a.shuffle.each do |i|
+      expect(@h.delete("key#{i}")).to eql(2 * i)
+    end
+  end
+
+  it 'should persist all objects' do
+    db_name = generate_db_name(__FILE__ + "_persist")
+    store = PEROBS::Store.new(db_name)
+    h = store['hash'] = store.new(PEROBS::BigHash)
+    n = ENTRIES
+    n.times do |i|
+      h["key#{i}"] = 2 * i
+    end
+    expect(h.check).to be true
+    expect(h.length).to eql(n)
+    expect(store.check).to eql(0)
+    store.exit
+
+    store = PEROBS::Store.new(db_name)
+    expect(store.check).to eql(0)
+    h = store['hash']
+    n.times do |i|
+      expect(h["key#{i}"]).to eql(2 * i)
+    end
+    expect(h.check).to be true
+    expect(h.length).to eql(n)
+    store.delete_store
+  end
+
+end
+

data/test/BigTreeNode_spec.rb

@@ -0,0 +1,153 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2016, 2017 by Chris Schlaeger <chris@taskjuggler.org>
+#
+# MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'fileutils'
+
+require 'spec_helper'
+require 'perobs/Store'
+require 'perobs/BigTree'
+
+describe PEROBS::BigTreeNode do
+
+  before(:all) do
+    @db_name = generate_db_name(__FILE__)
+    @store = PEROBS::Store.new(@db_name)
+    @store['bigtree'] = @t = @store.new(PEROBS::BigTree, 4)
+  end
+
+  before(:each) do
+    @t.clear
+  end
+
+  after(:all) do
+    @store.delete_store
+  end
+
+  it 'should insert a key/value pair' do
+    n = @t.root
+    n.insert(0, 0)
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(1)
+    expect(s.branch_nodes).to eql(0)
+    expect(s.min_depth).to eql(1)
+    expect(s.max_depth).to eql(1)
+    node_chain = @t.node_chain(0)
+    expect(node_chain.size).to eql(1)
+    expect(node_chain.first).to eql(n)
+  end
+
+  it 'should split a leaf node that becomes full' do
+    4.times { |n| @t.insert(n, n) }
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(1)
+    @t.insert(4, 4)
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(2)
+    expect(s.branch_nodes).to eql(1)
+    expect(s.min_depth).to eql(2)
+    expect(s.max_depth).to eql(2)
+  end
+
+  it 'should split a branch node that becomes full' do
+    11.times { |n| @t.insert(n, n) }
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(5)
+    expect(s.branch_nodes).to eql(1)
+    expect(s.min_depth).to eql(2)
+    expect(s.max_depth).to eql(2)
+    @t.insert(11, 11)
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(5)
+    expect(s.branch_nodes).to eql(3)
+    expect(s.min_depth).to eql(3)
+    expect(s.max_depth).to eql(3)
+  end
+
+  it 'should merge leaf node with next sibling' do
+    5.times { |n| @t.insert(n, n) }
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(2)
+
+    @t.remove(0)
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(1)
+    expect(s.min_depth).to eql(1)
+    expect(s.max_depth).to eql(1)
+  end
+
+  it 'should merge leaf node with previous siblin' do
+    5.times { |n| @t.insert(n, n) }
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(2)
+
+    @t.remove(2)
+    @t.remove(3)
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(1)
+  end
+
+  it 'should merge branch node with next sibling' do
+    12.times { |n| @t.insert(n, n) }
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(5)
+    expect(s.branch_nodes).to eql(3)
+
+    @t.remove(2)
+    @t.remove(3)
+    @t.remove(4)
+    @t.remove(5)
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(3)
+    expect(s.branch_nodes).to eql(1)
+  end
+
+  it 'should merge branch node with previous sibling' do
+    12.times { |n| @t.insert(n, n) }
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(5)
+    expect(s.branch_nodes).to eql(3)
+
+    @t.remove(4)
+    @t.remove(5)
+    @t.remove(2)
+    @t.remove(3)
+    expect(@t.check).to be true
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(3)
+    expect(s.branch_nodes).to eql(1)
+  end
+
+end
+

data/test/BigTree_spec.rb

@@ -0,0 +1,259 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2016, 2017 by Chris Schlaeger <chris@taskjuggler.org>
+#
+# MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'fileutils'
+
+require 'spec_helper'
+require 'perobs/Store'
+require 'perobs/BigTree'
+
+describe PEROBS::BigTree do
+
+  ORDER = 7
+
+  before(:all) do
+    @db_name = generate_db_name(__FILE__)
+    @store = PEROBS::Store.new(@db_name)
+    @t = @store.new(PEROBS::BigTree, ORDER)
+  end
+
+  after(:all) do
+    @store.delete_store
+  end
+
+  it 'should be empty' do
+    expect(@t.empty?).to be true
+    expect(@t.length).to eql(0)
+    s = @t.statistics
+    expect(s.leaf_nodes).to eql(1)
+    expect(s.branch_nodes).to eql(0)
+    expect(s.min_depth).to eql(1)
+    expect(s.max_depth).to eql(1)
+  end
+
+  it 'should deal with requests for unknown keys' do
+    expect(@t.has_key?(42)).to be false
+    expect(@t.get(42)).to be_nil
+  end
+
+  it 'should support adding sequential key/value pairs' do
+    0.upto(ORDER ** 3) do |i|
+      @t.insert(i, 3 * i)
+      expect(@t.check).to be true
+      expect(@t.length).to eql(i + 1)
+      expect(@t.has_key?(i)).to be true
+      expect(@t.get(i)).to eql(3 * i)
+    end
+  end
+
+  it 'should iterate over the stored key and value pairs' do
+    i = 0
+    @t.each do |k, v|
+      expect(k).to eql(i)
+      expect(v).to eql(3 * i)
+      i += 1
+    end
+    expect(i).to eql(ORDER ** 3 + 1)
+  end
+
+  it 'should iterate in reverse order over the stored key and value pairs' do
+    i = ORDER ** 3
+    @t.reverse_each do |k, v|
+      expect(k).to eql(i)
+      expect(v).to eql(3 * i)
+      i -= 1
+    end
+    expect(i).to eql(-1)
+  end
+
+  it 'should yield the key/value pairs on check' do
+    i = 0
+    @t.check do |k, v|
+      expect(k).to eql(k)
+      expect(v).to eql(3 * k)
+      i += 1
+    end
+    expect(i).to eql(ORDER ** 3 + 1)
+  end
+
+  it 'should support overwriting existing entries' do
+    0.upto(ORDER ** 3) do |i|
+      @t.insert(i, 7 * i)
+      expect(@t.check).to be true
+      expect(@t.length).to eql(ORDER ** 3 + 1)
+      expect(@t.has_key?(i)).to be true
+      expect(@t.get(i)).to eql(7 * i)
+    end
+  end
+
+  it 'should support clearing the tree' do
+    @t.clear
+    expect(@t.check).to be true
+    expect(@t.empty?).to be true
+    expect(@t.length).to eql(0)
+    i = 0
+    @t.each { |k, v| i += 1 }
+    expect(i).to eql(0)
+  end
+
+  it 'should support adding random key/value pairs' do
+    (1..ORDER ** 3).to_a.shuffle.each do |i|
+      @t.insert(i, i * 100)
+    end
+    expect(@t.check).to be true
+    (1..ORDER ** 3).to_a.shuffle.each do |i|
+      expect(@t.get(i)).to eql(i * 100)
+    end
+  end
+
+  it 'should support removing keys in random order' do
+    @t.clear
+    (1..ORDER ** 3).to_a.shuffle.each do |i|
+      @t.insert(i, i * 100)
+    end
+    expect(@t.length).to eql(ORDER ** 3)
+    (1..ORDER ** 3).to_a.shuffle.each do |i|
+      expect(@t.remove(i)).to eql(i * 100)
+      expect(@t.check).to be true
+    end
+    expect(@t.length).to eql(0)
+  end
+
+  it 'should support removing keys in increasing order' do
+    @t.clear
+    (1..ORDER ** 3).to_a.shuffle.each do |i|
+      @t.insert(i, i * 100)
+    end
+    expect(@t.length).to eql(ORDER ** 3)
+    (1..ORDER ** 3).to_a.each do |i|
+      expect(@t.remove(i)).to eql(i * 100)
+      expect(@t.check).to be true
+    end
+    expect(@t.length).to eql(0)
+  end
+
+  it 'should support removing keys in reverse order' do
+    @t.clear
+    (1..ORDER ** 3).to_a.shuffle.each do |i|
+      @t.insert(i, i * 100)
+    end
+    expect(@t.length).to eql(ORDER ** 3)
+    (1..ORDER ** 3).to_a.reverse_each do |i|
+      expect(@t.remove(i)).to eql(i * 100)
+      expect(@t.check).to be true
+    end
+    expect(@t.length).to eql(0)
+  end
+
+  it 'should persist the data' do
+    db_name = generate_db_name(__FILE__ + '_persist')
+    store = PEROBS::Store.new(db_name)
+    store['bigtree'] = t = store.new(PEROBS::BigTree, 4)
+    10.times do |i|
+      t.insert(i, i)
+    end
+    10.times do |i|
+      expect(t.get(i)).to eql(i)
+    end
+    store.exit
+
+    store = PEROBS::Store.new(db_name)
+    t = store['bigtree']
+    10.times do |i|
+      expect(t.get(i)).to eql(i)
+    end
+    store.delete_store
+  end
+
+  it 'should delete all entries matching a condition' do
+    @t.clear
+    (1..50).to_a.shuffle.each do |i|
+      @t.insert(i, i)
+    end
+    @t.delete_if { |k, v| v % 7 == 0 }
+    expect(@t.check).to be true
+    @t.each do |k, v|
+      expect(v % 7).to be > 0, "failed for #{v}"
+    end
+    expect(@t.length).to eql(43)
+    @t.delete_if { |k, v| v % 2 == 0 }
+    expect(@t.check).to be true
+    @t.each do |k, v|
+      expect(v % 2).to be > 0
+    end
+    expect(@t.length).to eql(21)
+    @t.delete_if { |k, v| true }
+    expect(@t.check).to be true
+    expect(@t.empty?).to be true
+  end
+
+  it 'should survive a real-world usage test' do
+    @t.clear
+    ref = {}
+    0.upto(1000) do
+      case rand(5)
+      when 0
+        0.upto(2) do
+          key = rand(100000)
+          value = key * 10
+          @t.insert(key, value)
+          ref[key] = value
+        end
+      when 1
+        if ref.length > 0
+          key = ref.keys[rand(ref.keys.length)]
+          expect(@t.remove(key)).to eql(ref[key])
+          ref.delete(key)
+        end
+      when 2
+        if ref.length > 0
+          0.upto(3) do
+            key = ref.keys[rand(ref.keys.length)]
+            expect(@t.get(key)).to eql(ref[key])
+          end
+        end
+      when 3
+        if ref.length > 0
+          key = ref.keys[rand(ref.keys.length)]
+          value = ref[key] + 1
+          @t.insert(key, value)
+          ref[key] = value
+        end
+      when 4
+        if rand(50) == 0
+          expect(@t.check).to be true
+        end
+      end
+    end
+
+    i = 0
+    @t.each do |k, v|
+      expect(ref[k]).to eql(v)
+      i += 1
+    end
+    expect(i).to eql(ref.length)
+  end
+
+end