perobs 3.0.1 → 4.3.0

data/test/LegacyDBs/version_3/class_map.json

@@ -0,0 +1 @@
+{"PEROBS::Hash":0,"PEROBS::Array":1,"LegacyDB::Fragment":2}

data/test/LegacyDBs/version_3/config.json

@@ -0,0 +1 @@
+{"serializer":{"json_class":"Symbol","s":"json"}}

data/test/LegacyDBs/version_3/version

@@ -0,0 +1 @@
+3

data/test/LockFile_spec.rb

@@ -30,7 +30,11 @@ require 'perobs/LockFile'
 describe PEROBS::LockFile do
 
   before(:each) do
-    @dir = Dir.mktmpdir('LockFile')
+    PEROBS.log.open($stderr)
+    PEROBS.log.level = Logger::INFO
+    @dir = File.join(Dir.tmpdir,
+                        "#{File.basename('LockFile_spec')}.#{rand(2**32)}")
+    FileUtils.mkdir_p(@dir)
     @file = File.join(@dir, 'LockFile.lock')
   end
 
@@ -42,7 +46,6 @@ describe PEROBS::LockFile do
     capture_io do
       expect(PEROBS::LockFile.new('/foo/bar/foobar').lock).to be false
     end
-    PEROBS.log.open($stderr)
   end
 
   it 'should support taking and releasing the lock' do
@@ -59,7 +62,7 @@ describe PEROBS::LockFile do
     expect(lock.is_locked?).to be true
     lock.forced_unlock
     expect(lock.is_locked?).to be false
-    out = capture_io{ expect(lock.unlock).to be false }
+    out = capture_io{ expect(lock.unlock).to be false }.log
     expect(out).to include('There is no current lock to release')
   end
 
@@ -67,7 +70,7 @@ describe PEROBS::LockFile do
     lock1 = PEROBS::LockFile.new(@file)
     expect(lock1.lock).to be true
     lock2 = PEROBS::LockFile.new(@file)
-    out = capture_io { expect(lock2.lock).to be false }
+    out = capture_io { expect(lock2.lock).to be false }.log
     expect(out).to include('due to timeout')
     expect(lock1.unlock).to be true
     expect(lock2.lock).to be true
@@ -105,7 +108,7 @@ describe PEROBS::LockFile do
     end
     lock2 = PEROBS::LockFile.new(@file,
                                  { :max_retries => 2, :pause_secs => 0.5 })
-    out = capture_io { expect(lock2.lock).to be false }
+    out = capture_io { expect(lock2.lock).to be false }.log
     expect(out).to include('due to timeout')
     Process.wait(pid)
   end
@@ -123,7 +126,7 @@ describe PEROBS::LockFile do
     end
 
     lock2 = PEROBS::LockFile.new(@file, { :timeout_secs => 1 })
-    out = capture_io { expect(lock2.lock).to be true }
+    out = capture_io { expect(lock2.lock).to be true }.log
     expect(out).to include('Old lock file found for PID')
     expect(lock2.unlock).to be true
     Process.wait(pid)

data/test/Object_spec.rb

@@ -28,7 +28,7 @@ require 'perobs'
 
 class O1_Object < PEROBS::Object
 
-  po_attr :a1
+  attr_persist :a1
 
   def initialize(store)
     super
@@ -38,7 +38,7 @@ end
 
 class O2_Object < PEROBS::Object
 
-  po_attr :a1, :a2, :a3, :a4
+  attr_persist :a1, :a2, :a3, :a4
 
   def initialize(store)
     super
@@ -99,7 +99,7 @@ describe PEROBS::Store do
     expect(o2.a1).to be_nil
     expect(o2.a3).to eq(o1)
     expect(o2.a4).to eq(42)
-    @store.sync
+    @store.exit
   end
 
   it 'should persist assigned values' do
@@ -114,7 +114,7 @@ describe PEROBS::Store do
       @store['o3'] = o3 = @store.new(O1_Object)
       o3.a1 = @store.new(PEROBS::Array)
     end
-    @store.sync
+    @store.exit
     @store = nil
     GC.start
 
@@ -163,7 +163,7 @@ describe PEROBS::Store do
   it 'should raise an error when no attributes are defined' do
     @store['o3'] = @store.new(O3)
     PEROBS.log.open(StringIO.new)
-    expect { @store.sync }.to raise_error(PEROBS::FatalError)
+    expect { @store.exit }.to raise_error(PEROBS::FatalError)
     PEROBS.log.open($stderr)
   end
 

data/test/SpaceManager_spec.rb

@@ -0,0 +1,176 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2020 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/SpaceManager'
+require 'perobs/ProgressMeter'
+
+describe PEROBS::SpaceManager do
+
+  before(:all) do
+    @db_dir = generate_db_name('SpaceManager')
+    FileUtils.mkdir_p(@db_dir)
+    @m = PEROBS::SpaceManager.new(@db_dir, PEROBS::ProgressMeter.new, 5)
+    PEROBS.log.level = Logger::ERROR
+    PEROBS.log.open($stderr)
+  end
+
+  after(:all) do
+    FileUtils.rm_rf(@db_dir)
+  end
+
+  it 'should open the space manager' do
+    @m.open
+    expect(@m.to_a).to eql([])
+  end
+
+  it 'should support adding spaces' do
+    @m.add_space(80, 8)
+    expect(@m.has_space?(80, 8)).to be true
+    expect(@m.to_a).to eql([[80, 8]])
+    expect(@m.check).to be true
+    @m.add_space(40, 4)
+    expect(@m.has_space?(40, 4)).to be true
+    expect(@m.to_a).to eql([[40, 4], [80, 8]])
+    @m.add_space(20, 2)
+    expect(@m.has_space?(20, 2)).to be true
+    expect(@m.to_a).to eql([[20, 2], [40, 4], [80, 8]])
+    @m.add_space(160, 16)
+    expect(@m.has_space?(160, 16)).to be true
+    expect(@m.to_a).to eql([[20, 2], [40, 4], [80, 8], [160, 16]])
+    @m.add_space(320, 32)
+    expect(@m.has_space?(320, 32)).to be true
+    expect(@m.to_a).to eql([[20, 2], [40, 4], [80, 8], [160, 16], [320, 32]])
+    @m.add_space(100, 10)
+    expect(@m.has_space?(100, 10)).to be true
+    expect(@m.to_a).to eql([[20, 2], [40, 4], [80, 8], [100, 10], [160, 16], [320, 32]])
+    @m.add_space(81, 8)
+    expect(@m.has_space?(81, 8)).to be true
+    expect(@m.to_a).to eql([[20, 2], [40, 4], [80, 8], [81, 8], [100, 10], [160, 16], [320, 32]])
+    expect(@m.check).to be true
+  end
+
+  it 'should keep values over an close/open' do
+    @m.add_space(1, 15)
+    expect(@m.check).to be true
+    @m.close
+    @m.open
+    expect(@m.check).to be true
+    expect(@m.to_a).to eql([[1, 15], [20, 2], [40, 4], [80, 8], [81, 8], [100, 10], [160, 16], [320, 32]])
+  end
+
+  it 'should support clearing all spaces' do
+    @m.clear
+    expect(@m.to_a).to eql([])
+    @m.add_space(1, 1)
+    @m.add_space(2, 2)
+    @m.clear
+    expect(@m.to_a).to eql([])
+  end
+
+  it 'should return exactly matching spaces' do
+    @m.clear
+    add_sizes([ 10, 5, 15, 10 ])
+    expect(@m.to_a).to eql([[0, 10], [1, 5], [2, 15], [3, 10]])
+    expect(@m.get_space(10)).to eql([3, 10])
+    expect(@m.get_space(10)).to eql([0, 10])
+    expect(@m.to_a).to eql([[1, 5], [2, 15]])
+    expect(@m.added_spaces).to eql(4)
+    expect(@m.recycled_spaces).to eql(2)
+    expect(@m.failed_requests).to eql(0)
+
+    @m.clear
+    add_sizes([ 10, 5, 15, 10, 10 ])
+    expect(@m.to_a).to eql([[0, 10], [1, 5], [2, 15], [3, 10], [4, 10]])
+    expect(@m.get_space(10)).to eql([4, 10])
+    expect(@m.get_space(10)).to eql([3, 10])
+    expect(@m.get_space(10)).to eql([0, 10])
+    expect(@m.to_a).to eql([[1, 5], [2, 15]])
+    expect(@m.added_spaces).to eql(5)
+    expect(@m.recycled_spaces).to eql(3)
+    expect(@m.failed_requests).to eql(0)
+  end
+
+  it "should return nil if no space can be found" do
+    expect(@m.get_space(42)).to be nil
+    expect(@m.get_space(9)).to be nil
+    expect(@m.get_space(11)).to be nil
+    expect(@m.recycled_spaces).to eql(3)
+    expect(@m.failed_requests).to eql(3)
+  end
+
+  it 'should support a real-world traffic pattern' do
+    address = 0
+    spaces = []
+    @m.clear
+    0.upto(1500) do
+      case rand(4)
+      when 0
+        # Insert new values
+        rand(9).times do
+          size = 20 + rand(80)
+          @m.add_space(address, size)
+          spaces << [ address, size ]
+          address += size
+        end
+      when 1
+        # Remove some values
+        rand(7).times do
+          size = rand(110)
+          if (space = @m.get_space(size))
+            expect(spaces.include?(space)).to be true
+            spaces.delete(space)
+          end
+        end
+      when 2
+        if rand(10) == 0
+          expect(@m.check).to be true
+          spaces.each do |address, size|
+            expect(@m.has_space?(address, size)).to be true
+          end
+          @m.to_a.each do |address, size|
+            expect(spaces.include?([ address, size ])).to be true
+          end
+        end
+      when 3
+        if rand(200) == 0
+          expect(@m.check).to be true
+          @m.close
+          @m.open
+          expect(@m.check).to be true
+        end
+      end
+    end
+  end
+
+  def add_sizes(sizes)
+    sizes.each_with_index do |size, i|
+      @m.add_space(i, size)
+    end
+  end
+
+end

data/test/SpaceTree_spec.rb

@@ -27,13 +27,16 @@ require 'fileutils'
 
 require 'spec_helper'
 require 'perobs/SpaceTree'
+require 'perobs/ProgressMeter'
 
 describe PEROBS::SpaceTree do
 
   before(:all) do
     @db_dir = generate_db_name('SpaceTree')
     FileUtils.mkdir_p(@db_dir)
-    @m = PEROBS::SpaceTree.new(@db_dir)
+    @m = PEROBS::SpaceTree.new(@db_dir, PEROBS::ProgressMeter.new)
+    PEROBS.log.level = Logger::ERROR
+    PEROBS.log.open($stderr)
   end
 
   after(:all) do
@@ -94,12 +97,12 @@ EOT
   end
 
   it 'should find the smallest node' do
-    node = @m.instance_variable_get('@root').find_smallest_node
+    node = @m.root.find_smallest_node
     expect(node.size).to eql(2)
   end
 
   it 'should find the largest node' do
-    node = @m.instance_variable_get('@root').find_largest_node
+    node = @m.root.find_largest_node
     expect(node.size).to eql(32)
     expect(node.node_address).to eql(5)
     expect(node.parent.size).to eql(16)
@@ -119,12 +122,14 @@ EOT
     add_sizes([ 10, 5, 15, 10 ])
     expect(@m.to_a).to eql([[0, 10], [1, 5], [3, 10], [2, 15]])
     expect(@m.get_space(10)).to eql([0, 10])
+    expect(@m.to_a).to eql([[3, 10], [1, 5], [2, 15]])
 
     @m.clear
     add_sizes([ 10, 5, 15, 10, 10 ])
     expect(@m.to_a).to eql([[0, 10], [1, 5], [4, 10], [3, 10], [2, 15]])
     expect(@m.get_space(10)).to eql([0, 10])
     expect(@m.get_space(10)).to eql([4, 10])
+    expect(@m.to_a).to eql([[3, 10], [1, 5], [2, 15]])
   end
 
   it 'should delete a smaller node' do
@@ -208,14 +213,15 @@ EOT
   it 'should support a real-world traffic pattern' do
     address = 0
     spaces = []
-    0.upto(500) do
-      case rand(3)
+    @m.clear
+    0.upto(1000) do
+      case rand(4)
       when 0
         # Insert new values
         rand(9).times do
           size = 20 + rand(5000)
           @m.add_space(address, size)
-          spaces << [address, size]
+          spaces << [ address, size ]
           address += size
         end
       when 1
@@ -228,9 +234,21 @@ EOT
           end
         end
       when 2
-        expect(@m.check).to be true
-        spaces.each do |address, size|
-          expect(@m.has_space?(address, size)).to be true
+        if rand(10) == 0
+          expect(@m.check).to be true
+          spaces.each do |address, size|
+            expect(@m.has_space?(address, size)).to be true
+          end
+          @m.each do |address, size|
+            expect(spaces.include?([ address, size ])).to be true
+          end
+        end
+      when 3
+        if rand(100) == 0
+          expect(@m.check).to be true
+          @m.close
+          @m.open
+          expect(@m.check).to be true
         end
       end
     end

data/test/Store_spec.rb

@@ -31,9 +31,9 @@ end
 
 class Person < PEROBS::Object
 
-  po_attr :name, :zip, :bmi, :married, :related, :relatives
+  attr_persist :name, :zip, :bmi, :married, :related, :relatives
 
-  def initialize(store)
+  def initialize(p)
     super
     attr_init(:name, '')
     attr_init(:bmi, 22.2)
@@ -44,9 +44,9 @@ end
 
 class PersonN < PEROBS::Object
 
-  po_attr :name, :zip, :bmi, :married, :related, :relatives
+  attr_persist :name, :zip, :bmi, :married, :related, :relatives
 
-  def initialize(store)
+  def initialize(p)
     super
     attr_init(:name, '')
     attr_init(:bmi, 22.2)
@@ -57,17 +57,17 @@ end
 
 class O0 < PEROBS::Object
 
-  po_attr :child
+  attr_persist :child
 
-  def initialize(store)
+  def initialize(p)
     super
-    self.child = @store.new(O1, myself)
+    self.child = p.store.new(O1, myself)
   end
 
 end
 class O1 < PEROBS::Object
 
-  po_attr :parent
+  attr_persist :parent
 
   def initialize(store, p = nil)
     super(store)
@@ -84,22 +84,16 @@ describe PEROBS::Store do
   end
 
   after(:each) do
-    @store.gc
-    expect { @store.check }.to_not raise_error
-    expect { @store.delete_store }.to_not raise_error
-  end
-
-  after(:all) do
     FileUtils.rm_rf(@db_file)
   end
 
   it 'should @store simple objects' do
-    @store = PEROBS::Store.new(@db_file, { :serializer => :yaml })
-    @store['john'] = john = @store.new(Person)
+    store = PEROBS::Store.new(@db_file, { :serializer => :yaml })
+    store['john'] = john = store.new(Person)
     john.name = 'John'
     john.zip = 4060
     john.bmi = 25.5
-    @store['jane'] = jane = @store.new(Person)
+    store['jane'] = jane = store.new(Person)
     jane.name = 'Jane'
     jane.related = john
     jane.married = true
@@ -110,48 +104,56 @@ describe PEROBS::Store do
     expect(john.bmi).to eq(25.5)
     expect(john.married).to be false
     expect(john.related).to be_nil
-    jane = @store['jane']
+    jane = store['jane']
     expect(jane.name).to eq('Jane')
     expect(jane.related).to eq(john)
     expect(jane.married).to be true
+
+    capture_io { store.gc }
+    capture_io { expect { store.check }.to_not raise_error }
+    expect { store.delete_store }.to_not raise_error
   end
 
   it 'should @store and retrieve simple objects' do
     [ :marshal, :json, :yaml ].each do |serializer|
       FileUtils.rm_rf(@db_file)
-      @store = PEROBS::Store.new(@db_file, { :serializer => serializer })
-      @store['john'] = john = @store.new(Person)
+      store = PEROBS::Store.new(@db_file, { :serializer => serializer })
+      store['john'] = john = store.new(Person)
       john.name = 'John'
       john.zip = 4060
       john.bmi = 25.5
-      @store['jane'] = jane = @store.new(Person)
+      store['jane'] = jane = store.new(Person)
       jane.name = 'Jane'
       jane.related = john
       jane.married = true
       jane.relatives = 'test'
 
-      @store.sync
+      capture_io { store.exit }
 
-      @store = PEROBS::Store.new(@db_file)
-      john = @store['john']
+      store = PEROBS::Store.new(@db_file)
+      john = store['john']
       expect(john.name).to eq('John')
       expect(john.zip).to eq(4060)
       expect(john.bmi).to eq(25.5)
       expect(john.married).to be false
       expect(john.related).to be_nil
-      jane = @store['jane']
+      jane = store['jane']
       expect(jane.name).to eq('Jane')
       expect(jane.related).to eq(john)
       expect(jane.married).to be true
+
+      capture_io { store.gc }
+      capture_io { expect { store.check }.to_not raise_error }
+      expect { store.delete_store }.to_not raise_error
     end
   end
 
   it 'should flush cached objects when necessary' do
-    @store = PEROBS::Store.new(@db_file, :cache_bits => 3)
+    store = PEROBS::Store.new(@db_file, :cache_bits => 3)
     last_obj = nil
     0.upto(20) do |i|
-      @store["person#{i}"] = obj = @store.new(Person)
-      expect(@store["person#{i}"]).to eq(obj)
+      store["person#{i}"] = obj = store.new(Person)
+      expect(store["person#{i}"]).to eq(obj)
       obj.name = "Person #{i}"
       expect(obj.name).to eq("Person #{i}")
       obj.related = last_obj
@@ -159,164 +161,228 @@ describe PEROBS::Store do
       last_obj = obj
     end
     0.upto(20) do |i|
-      expect(@store["person#{i}"].name).to eq("Person #{i}")
+      expect(store["person#{i}"].name).to eq("Person #{i}")
     end
+
+    capture_io { store.gc }
+    capture_io { expect { store.check }.to_not raise_error }
+    expect { store.delete_store }.to_not raise_error
   end
 
   it 'should support renaming of classes' do
-    @store = PEROBS::Store.new(@db_file)
-    @store['john'] = john = @store.new(Person)
+    store = PEROBS::Store.new(@db_file)
+    store['john'] = john = store.new(Person)
     john.name = 'John'
     john.zip = 4060
     john.bmi = 25.5
-    @store['jane'] = jane = @store.new(Person)
+    store['jane'] = jane = store.new(Person)
     jane.name = 'Jane'
     jane.related = john
     jane.married = true
     jane.relatives = 'test'
 
-    @store.sync
+    capture_io { store.exit }
 
-    @store = PEROBS::Store.new(@db_file)
-    @store.rename_classes({ 'Person' => 'PersonN' })
-    john = @store['john']
+    store = PEROBS::Store.new(@db_file)
+    store.rename_classes({ 'Person' => 'PersonN' })
+    john = store['john']
     expect(john.name).to eq('John')
     expect(john.zip).to eq(4060)
     expect(john.bmi).to eq(25.5)
     expect(john.married).to be false
     expect(john.related).to be_nil
-    jane = @store['jane']
+    jane = store['jane']
     expect(jane.name).to eq('Jane')
     expect(jane.related).to eq(john)
     expect(jane.married).to be true
+
+    capture_io { store.gc }
+    capture_io { expect { store.check }.to_not raise_error }
+    expect { store.delete_store }.to_not raise_error
   end
 
   it 'should detect modification to non-working objects' do
-    @store = PEROBS::Store.new(@db_file, :cache_bits => 3)
+    store = PEROBS::Store.new(@db_file, :cache_bits => 3)
     0.upto(20) do |i|
-      @store["person#{i}"] = obj = @store.new(Person)
+      store["person#{i}"] = obj = store.new(Person)
       obj.name = "Person #{i}"
     end
     0.upto(20) do |i|
-      @store["person#{i}"].name = "New Person #{i}"
+      store["person#{i}"].name = "New Person #{i}"
     end
-    @store.sync
-    @store = PEROBS::Store.new(@db_file)
+    capture_io { store.exit }
+    store = PEROBS::Store.new(@db_file)
     0.upto(20) do |i|
-      expect(@store["person#{i}"].name).to eq("New Person #{i}")
+      expect(store["person#{i}"].name).to eq("New Person #{i}")
     end
+
+    capture_io { store.gc }
+    capture_io { expect { store.check }.to_not raise_error }
+    expect { store.delete_store }.to_not raise_error
   end
 
   it 'should garbage collect unlinked objects' do
-    @store = PEROBS::Store.new(@db_file)
-    @store['person1'] = obj = @store.new(Person)
-    id1 = obj._id
-    @store['person2'] = obj = @store.new(Person)
-    id2 = obj._id
-    obj.related = obj = @store.new(Person)
-    id3 = obj._id
-    @store.sync
-    @store['person1'] = nil
-    @store.gc
-    @store = PEROBS::Store.new(@db_file)
-    expect(@store.object_by_id(id1)).to be_nil
-    expect(@store['person2']._id).to eq(id2)
-    expect(@store['person2'].related._id).to eq(id3)
+    store = PEROBS::Store.new(@db_file)
+    persons = []
+    0.upto(20) do |i|
+      persons[i] = obj = store.new(Person)
+      obj.name = "person#{i}"
+      if i < 3
+        store["person#{i}"] = obj
+      else
+        persons[i - 3].related = obj
+      end
+    end
+    store.sync
+    expect(store.size).to eq(21)
+
+    store['person0'] = nil
+    capture_io { store.gc }
+    expect(store.size).to eq(14)
+    capture_io { expect { store.check }.to_not raise_error }
+    capture_io { store.exit }
+    store = PEROBS::Store.new(@db_file)
+    capture_io { expect { store.check }.to_not raise_error }
+
+    person = store['person1']
+    i = 0
+    while (person = person.related) do
+      i += 1
+    end
+    expect(i).to eq(6)
+
+    capture_io { store.gc }
+    capture_io { expect { store.check }.to_not raise_error }
+    capture_io { store.exit }
+
+    store = PEROBS::Store.new(@db_file)
+    capture_io { expect { store.check }.to_not raise_error }
+
+    person = store['person1']
+    i = 0
+    while (person = person.related) do
+      i += 1
+    end
+    expect(i).to eq(6)
+
+    capture_io { store.gc }
+    capture_io { expect { store.check }.to_not raise_error }
+    expect { store.delete_store }.to_not raise_error
   end
 
   it 'should handle cyclicly linked objects' do
-    @store = PEROBS::Store.new(@db_file)
-    @store['person0'] = p0 = @store.new(Person)
+    store = PEROBS::Store.new(@db_file)
+    store['person0'] = p0 = store.new(Person)
     id0 = p0._id
-    p1 = @store.new(Person)
+    p1 = store.new(Person)
     id1 = p1._id
-    p2 = @store.new(Person)
+    p2 = store.new(Person)
     id2 = p2._id
     p1.related = p2
     p2.related = p1
     p0.related = p1
-    expect(@store.check).to eq(0)
-    expect(@store.gc).to eq(0)
+    capture_io { expect(store.check).to eq(0) }
+    capture_io { expect(store.gc).to eq(0) }
     p0 = p1 = p2 = nil
-    GC.start
-    @store = PEROBS::Store.new(@db_file)
-    expect(@store['person0']._id).to eq(id0)
-    expect(@store['person0'].related._id).to eq(id1)
-    expect(@store['person0'].related.related._id).to eq(id2)
-
-    @store['person0'].related = nil
-    expect(@store.gc).to eq(2)
-    GC.start
-    expect(@store.object_by_id(id1)).to be_nil
-    expect(@store.object_by_id(id2)).to be_nil
-
-    @store = PEROBS::Store.new(@db_file)
-    expect(@store.check).to eq(0)
-    expect(@store.object_by_id(id1)).to be_nil
-    expect(@store.object_by_id(id2)).to be_nil
+    capture_io { store.exit }
+    store = PEROBS::Store.new(@db_file)
+    expect(store['person0']._id).to eq(id0)
+    expect(store['person0'].related._id).to eq(id1)
+    expect(store['person0'].related.related._id).to eq(id2)
+
+    store['person0'].related = nil
+    capture_io { expect(store.gc).to eq(2) }
+    stats = store.statistics
+    expect(stats.swept_objects).to eql(2)
+    capture_io { store.exit }
+
+    store = PEROBS::Store.new(@db_file)
+    capture_io { expect(store.check).to eq(0) }
+    expect(store.object_by_id(id1)).to be_nil
+    expect(store.object_by_id(id2)).to be_nil
+
+    capture_io { store.gc }
+    capture_io { expect { store.check }.to_not raise_error }
+    expect { store.delete_store }.to_not raise_error
   end
 
   it 'should support a successful transaction' do
-    @store = PEROBS::Store.new(@db_file)
-    @store.transaction do
-      @store['person0'] = p0 = @store.new(Person)
+    store = PEROBS::Store.new(@db_file)
+    store.transaction do
+      store['person0'] = p0 = store.new(Person)
       p0.name = 'Jimmy'
     end
-    expect(@store['person0'].name).to eq('Jimmy')
+    expect(store['person0'].name).to eq('Jimmy')
+
+    capture_io { store.gc }
+    capture_io { expect { store.check }.to_not raise_error }
+    expect { store.delete_store }.to_not raise_error
   end
 
   it 'should handle a failed transaction 1' do
-    @store = PEROBS::Store.new(@db_file)
+    store = PEROBS::Store.new(@db_file)
     begin
-      @store.transaction do
-        @store['person0'] = p0 = @store.new(Person)
+      store.transaction do
+        store['person0'] = p0 = store.new(Person)
         p0.name = 'Jimmy'
         raise POSError
       end
     rescue POSError
     end
-    expect(@store['person0']).to be_nil
+    expect(store['person0']).to be_nil
+
+    capture_io { store.gc }
+    capture_io { expect { store.check }.to_not raise_error }
+    expect { store.delete_store }.to_not raise_error
   end
 
   it 'should handle a failed transaction 2' do
-    @store = PEROBS::Store.new(@db_file)
-    @store['person1'] = p1 = @store.new(Person)
+    store = PEROBS::Store.new(@db_file)
+    store['person1'] = p1 = store.new(Person)
     p1.name = 'Joe'
     begin
-      @store.transaction do
-        @store['person0'] = p0 = @store.new(Person)
+      store.transaction do
+        store['person0'] = p0 = store.new(Person)
         p0.name = 'Jimmy'
         raise POSError
       end
     rescue POSError
     end
-    expect(@store['person1'].name).to eq('Joe')
-    expect(@store['person0']).to be_nil
+    expect(store['person1'].name).to eq('Joe')
+    expect(store['person0']).to be_nil
+
+    capture_io { store.gc }
+    capture_io { expect { store.check }.to_not raise_error }
+    expect { store.delete_store }.to_not raise_error
   end
 
   it 'should support a successful nested transaction' do
-    @store = PEROBS::Store.new(@db_file)
-    @store.transaction do
-      @store['person0'] = p0 = @store.new(Person)
+    store = PEROBS::Store.new(@db_file)
+    store.transaction do
+      store['person0'] = p0 = store.new(Person)
       p0.name = 'Jimmy'
-      @store.transaction do
-        @store['person1'] = p1 = @store.new(Person)
+      store.transaction do
+        store['person1'] = p1 = store.new(Person)
         p1.name = 'Joe'
       end
     end
-    expect(@store['person0'].name).to eq('Jimmy')
-    expect(@store['person1'].name).to eq('Joe')
+    expect(store['person0'].name).to eq('Jimmy')
+    expect(store['person1'].name).to eq('Joe')
+
+    capture_io { store.gc }
+    capture_io { expect { store.check }.to_not raise_error }
+    expect { store.delete_store }.to_not raise_error
   end
 
   it 'should handle a failed nested transaction 1' do
-    @store = PEROBS::Store.new(@db_file)
+    store = PEROBS::Store.new(@db_file)
     begin
-      @store.transaction do
-        @store['person0'] = p0 = @store.new(Person)
+      store.transaction do
+        store['person0'] = p0 = store.new(Person)
         p0.name = 'Jimmy'
         begin
-          @store.transaction do
-            @store['person1'] = p1 = @store.new(Person)
+          store.transaction do
+            store['person1'] = p1 = store.new(Person)
             p1.name = 'Joe'
             raise POSError
           end
@@ -325,58 +391,70 @@ describe PEROBS::Store do
       end
     rescue POSError
     end
-    expect(@store['person0'].name).to eq('Jimmy')
-    expect(@store['person1']).to be_nil
+    expect(store['person0'].name).to eq('Jimmy')
+    expect(store['person1']).to be_nil
+
+    capture_io { store.gc }
+    capture_io { expect { store.check }.to_not raise_error }
+    expect { store.delete_store }.to_not raise_error
   end
 
   it 'should handle a failed nested transaction 2' do
-    @store = PEROBS::Store.new(@db_file)
+    store = PEROBS::Store.new(@db_file)
     begin
-      @store.transaction do
-        @store['person0'] = p0 = @store.new(Person)
+      store.transaction do
+        store['person0'] = p0 = store.new(Person)
         p0.name = 'Jimmy'
-        @store.transaction do
-          @store['person1'] = p1 = @store.new(Person)
+        store.transaction do
+          store['person1'] = p1 = store.new(Person)
           p1.name = 'Joe'
         end
         raise POSError
       end
     rescue POSError
     end
-    expect(@store['person0']).to be_nil
-    expect(@store['person1']).to be_nil
+    expect(store['person0']).to be_nil
+    expect(store['person1']).to be_nil
+
+    capture_io { store.gc }
+    capture_io { expect { store.check }.to_not raise_error }
+    expect { store.delete_store }.to_not raise_error
   end
 
   it 'should support a successful 2-level nested transaction' do
-    @store = PEROBS::Store.new(@db_file)
-    @store.transaction do
-      @store['person0'] = p0 = @store.new(Person)
+    store = PEROBS::Store.new(@db_file)
+    store.transaction do
+      store['person0'] = p0 = store.new(Person)
       p0.name = 'Jimmy'
-      @store.transaction do
-        @store['person1'] = p1 = @store.new(Person)
+      store.transaction do
+        store['person1'] = p1 = store.new(Person)
         p1.name = 'Joe'
-        @store.transaction do
-          @store['person2'] = p2 = @store.new(Person)
+        store.transaction do
+          store['person2'] = p2 = store.new(Person)
           p2.name = 'Jane'
         end
       end
     end
-    expect(@store['person0'].name).to eq('Jimmy')
-    expect(@store['person1'].name).to eq('Joe')
-    expect(@store['person2'].name).to eq('Jane')
+    expect(store['person0'].name).to eq('Jimmy')
+    expect(store['person1'].name).to eq('Joe')
+    expect(store['person2'].name).to eq('Jane')
+
+    capture_io { store.gc }
+    capture_io { expect { store.check }.to_not raise_error }
+    expect { store.delete_store }.to_not raise_error
   end
 
   it 'should handle a failed 2-level nested transaction 1' do
-    @store = PEROBS::Store.new(@db_file)
-    @store.transaction do
-      @store['person0'] = p0 = @store.new(Person)
+    store = PEROBS::Store.new(@db_file)
+    store.transaction do
+      store['person0'] = p0 = store.new(Person)
       p0.name = 'Jimmy'
-      @store.transaction do
-        @store['person1'] = p1 = @store.new(Person)
+      store.transaction do
+        store['person1'] = p1 = store.new(Person)
         p1.name = 'Joe'
         begin
-          @store.transaction do
-            @store['person2'] = p2 = @store.new(Person)
+          store.transaction do
+            store['person2'] = p2 = store.new(Person)
             p2.name = 'Jane'
             raise POSError
           end
@@ -384,22 +462,26 @@ describe PEROBS::Store do
         end
       end
     end
-    expect(@store['person0'].name).to eq('Jimmy')
-    expect(@store['person1'].name).to eq('Joe')
-    expect(@store['person2']).to be_nil
+    expect(store['person0'].name).to eq('Jimmy')
+    expect(store['person1'].name).to eq('Joe')
+    expect(store['person2']).to be_nil
+
+    capture_io { store.gc }
+    capture_io { expect { store.check }.to_not raise_error }
+    expect { store.delete_store }.to_not raise_error
   end
 
   it 'should handle a failed 2-level nested transaction 2' do
-    @store = PEROBS::Store.new(@db_file)
-    @store.transaction do
-      @store['person0'] = p0 = @store.new(Person)
+    store = PEROBS::Store.new(@db_file)
+    store.transaction do
+      store['person0'] = p0 = store.new(Person)
       p0.name = 'Jimmy'
-      @store.transaction do
-        @store['person1'] = p1 = @store.new(Person)
+      store.transaction do
+        store['person1'] = p1 = store.new(Person)
         p1.name = 'Joe'
         begin
-          @store.transaction do
-            @store['person2'] = p2 = @store.new(Person)
+          store.transaction do
+            store['person2'] = p2 = store.new(Person)
             p2.name = 'Jane'
             raise POSError
           end
@@ -408,144 +490,209 @@ describe PEROBS::Store do
         p1.name = 'Jane'
       end
     end
-    expect(@store['person0'].name).to eq('Jimmy')
-    expect(@store['person1'].name).to eq('Jane')
-    expect(@store['person2']).to be_nil
+    expect(store['person0'].name).to eq('Jimmy')
+    expect(store['person1'].name).to eq('Jane')
+    expect(store['person2']).to be_nil
+
+    capture_io { store.gc }
+    capture_io { expect { store.check }.to_not raise_error }
+    expect { store.delete_store }.to_not raise_error
   end
 
   it 'should track in-memory objects properly' do
-    @store = PEROBS::Store.new(@db_file)
-    expect(@store.statistics[:in_memory_objects]).to eq(1)
-    @store['person'] = @store.new(Person)
+    store = PEROBS::Store.new(@db_file)
+    expect(store.statistics[:in_memory_objects]).to eq(1)
+    store['person'] = store.new(Person)
     # We have the root hash and the Person object.
-    expect(@store.statistics[:in_memory_objects]).to eq(2)
-    @store.sync
-    GC.start
+    expect(store.statistics[:in_memory_objects]).to eq(2)
+    store.sync
     # Now the Person should be gone from memory.
-    expect(@store.statistics[:in_memory_objects]).to eq(1)
+    # Ruby 2.3 and later has changed the GC so that this does not work
+    # reliably anymore. The GC seems to operate lazyly.
+    #expect(store.statistics[:in_memory_objects]).to eq(1)
+
+    capture_io { store.gc }
+    capture_io { expect { store.check }.to_not raise_error }
+    expect { store.delete_store }.to_not raise_error
   end
 
   it 'should handle nested constructors' do
-    @store = PEROBS::Store.new(@db_file)
-    @store['root'] = @store.new(O0)
-    @store.sync
-    expect(@store.check).to eq(0)
-
-    @store = PEROBS::Store.new(@db_file)
-    expect(@store.check).to eq(0)
-    expect(@store['root'].child.parent).to eq(@store['root'])
+    store = PEROBS::Store.new(@db_file)
+    store['root'] = store.new(O0)
+    store.sync
+    capture_io { expect(store.check).to eq(0) }
+    capture_io { store.exit }
+
+    store = PEROBS::Store.new(@db_file)
+    capture_io { expect(store.check).to eq(0) }
+    expect(store['root'].child.parent).to eq(store['root'])
+
+    capture_io { store.gc }
+    capture_io { expect { store.check }.to_not raise_error }
+    expect { store.delete_store }.to_not raise_error
+  end
+
+  it 'should handle frequent updates of objects' do
+    store = PEROBS::Store.new(@db_file)
+    count = 10000
+    0.upto(count) do |i|
+      key = "Obj#{i}"
+      store[key] = p = store.new(Person)
+      p.name = "0:#{i}:" + 'X' * rand(64)
+    end
+
+    0.upto(10) do |iteration|
+      0.upto(count) do |i|
+        key = "Obj#{i}"
+        p = store[key]
+        p.name = "#{iteration}:#{i}:" + 'X' * rand(64)
+      end
+      0.upto(count) do |i|
+        key = "Obj#{i}"
+        p = store[key]
+        o_it, o_i, o_x = p.name.split(':')
+        if o_it.to_i != iteration
+          $stderr.puts "Mismatch of #{p._id} with value #{o_it}:#{i}"
+        end
+        expect(o_it.to_i).to eql(iteration)
+        expect(o_i.to_i).to eql(i)
+      end
+      capture_io { expect(store.check).to eql(0) }
+    end
+
+    capture_io { store.gc }
+    capture_io { expect { store.check }.to_not raise_error }
+    expect { store.delete_store }.to_not raise_error
   end
 
   it 'should survive a real world usage test' do
     options = { :engine => PEROBS::FlatFileDB }
-    @store = PEROBS::Store.new(@db_file, options)
+    store = PEROBS::Store.new(@db_file, options)
     ref = {}
 
     deletions_since_last_gc = 0
-    0.upto(15000) do |i|
+    0.upto(5000) do |i|
       key = "o#{i}"
-      case rand(8)
+      case rand(9)
       when 0
         # Add 'A' person
-        value = 'A' * rand(512)
-        @store[key] = p = @store.new(Person)
+        value = key + 'A' * rand(512)
+        store[key] = p = store.new(Person)
         p.name = value
         ref[key] = value
       when 1
         # Add 'B' person
-        value = 'B' * rand(128)
-        @store[key] = p = @store.new(Person)
+        value = key + 'B' * rand(32)
+        store[key] = p = store.new(Person)
         p.name = value
         ref[key] = value
       when 2
         # Delete a root entry
         if ref.keys.length > 11
-          key = ref.keys[(ref.keys.length / 11).to_i]
-          expect(@store[key]).not_to be_nil
-          @store[key] = nil
+          key = ref.keys[rand(ref.keys.length)]
+          expect(store[key]).not_to be_nil
+          store[key] = nil
           ref.delete(key)
           deletions_since_last_gc += 1
         end
       when 3
+        # Update a person entry
+        if ref.keys.length > 0
+          key = ref.keys[rand(ref.keys.length)]
+          expect(store[key]).not_to be_nil
+          value = key + 'C' * rand(996)
+          p = store[key]
+          p.name = value
+          ref[key] = value
+        end
+      when 4
         # Call garbage collector
         if rand(60) == 0
-          @store.gc
-          stats = @store.statistics
+          capture_io { store.gc }
+          stats = store.statistics
           expect(stats.marked_objects).to eq(ref.length)
           expect(stats.swept_objects).to eq(deletions_since_last_gc)
           deletions_since_last_gc = 0
-          expect(@store.gc).to eq(deletions_since_last_gc)
+          capture_io { expect(store.gc).to eq(deletions_since_last_gc) }
         end
-      when 4
+      when 5
         # Sync store and reload
         if rand(15) == 0
-          @store.exit
-          @store = PEROBS::Store.new(@db_file, options)
+          capture_io { store.exit }
+          store = PEROBS::Store.new(@db_file, options)
         end
-      when 5
+      when 6
         # Replace an entry with 'C' person
         if ref.keys.length > 13
           key = ref.keys[(ref.keys.length / 13).to_i]
-          value = 'C' * rand(1024)
-          @store[key] = p = @store.new(Person)
+          value = key + 'D' * rand(1024)
+          store[key] = p = store.new(Person)
           p.name = value
           ref[key] = value
           deletions_since_last_gc += 1
         end
-      when 6
+      when 7
         # Sync and check store
         if rand(50) == 0
-          @store.sync
-          expect(@store.check(false)).to eq(0)
+          #store.sync
+          capture_io { expect(store.check(false)).to eq(0) }
         end
-      when 7
+      when 8
         # Compare a random entry with reference entry
         if ref.keys.length > 0
-          key = ref.keys[rand(ref.keys.length - 1)]
-          expect(@store[key].name).to eq(ref[key])
+          key = ref.keys[rand(ref.keys.length)]
+          expect(store[key].name).to eq(ref[key])
         end
       end
       #ref.each do |k, v|
-      #  expect(@store[k].name).to eq(v), "failure in mode #{i}"
+      #  expect(store[k].name).to eq(v), "failure in mode #{i}"
       #end
     end
 
     ref.each do |k, v|
-      expect(@store[k].name).to eq(v)
+      expect(store[k].name).to eq(v)
     end
+
+    capture_io { store.gc }
+    capture_io { expect { store.check }.to_not raise_error }
+    expect { store.delete_store }.to_not raise_error
   end
 
   it 'should copy the database' do
-    @store = PEROBS::Store.new(@db_file)
-    @store['person0'] = p0 = @store.new(Person)
+    store = PEROBS::Store.new(@db_file)
+    store['person0'] = p0 = store.new(Person)
     id0 = p0._id
-    p1 = @store.new(Person)
+    p1 = store.new(Person)
     id1 = p1._id
-    p2 = @store.new(Person)
+    p2 = store.new(Person)
     id2 = p2._id
     p1.related = p2
     p2.related = p1
     p0.related = p1
-    p3 = @store.new(PEROBS::Array)
-    @store['persons'] = p3
+    p3 = store.new(PEROBS::Array)
+    store['persons'] = p3
     p3 << p0
     p3 << p1
     p3 << p2
     p0 = p1 = p2 = p3 = nil
-    expect(@store['person0']._id).to eq(id0)
-    expect(@store['person0'].related._id).to eq(id1)
-    expect(@store['person0'].related.related._id).to eq(id2)
-
-    @store.copy(@db_file_new, { :engine => PEROBS::FlatFileDB })
-    @store.delete_store
-
-    @store = PEROBS::Store.new(@db_file_new, { :engine => PEROBS::FlatFileDB })
-    expect(@store['person0']._id).to eq(id0)
-    expect(@store['person0'].related._id).to eq(id1)
-    expect(@store['person0'].related.related._id).to eq(id2)
-    expect(@store['persons'][0]).to eq(@store['person0'])
-    expect(@store['persons'][1]).to eq(@store['person0'].related)
-    expect(@store['persons'][2]).to eq(@store['person0'].related.related)
+    expect(store['person0']._id).to eq(id0)
+    expect(store['person0'].related._id).to eq(id1)
+    expect(store['person0'].related.related._id).to eq(id2)
+
+    store.copy(@db_file_new, { :engine => PEROBS::FlatFileDB })
+    store.delete_store
+
+    store = PEROBS::Store.new(@db_file_new, { :engine => PEROBS::FlatFileDB })
+    expect(store['person0']._id).to eq(id0)
+    expect(store['person0'].related._id).to eq(id1)
+    expect(store['person0'].related.related._id).to eq(id2)
+    expect(store['persons'][0]).to eq(store['person0'])
+    expect(store['persons'][1]).to eq(store['person0'].related)
+    expect(store['persons'][2]).to eq(store['person0'].related.related)
+
+    capture_io { store.gc }
+    capture_io { expect { store.check }.to_not raise_error }
+    expect { store.delete_store }.to_not raise_error
   end
 
 end