Migrate tests to RSpec

Author: pedroandrade

spec/ref/reference_queue_spec.rb

@@ -53,7 +53,7 @@
     end
   end
 
-  describe 'references are added immediately if the_object has been collected' do
+  context 'references are added immediately if the_object has been collected' do
     specify do
       Ref::Mock.use do
         ref = Ref::WeakReference.new(obj_1)
@@ -64,4 +64,20 @@
       end
     end
   end
-end
+
+  context 'references are added when the object has been collected' do
+    specify do
+      Ref::Mock.use do
+        ref = Ref::WeakReference.new(obj_1)
+        queue.monitor(ref)
+        result = queue.shift
+        expect(result).to eq nil
+
+        Ref::Mock.gc(obj_1)
+
+        object = queue.shift
+        expect(ref.referenced_object_id).to eq object.referenced_object_id
+      end
+    end
+  end
+ end

spec/ref/soft_key_map_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Ref::SoftKeyMap do
+  it_behaves_like 'a reference key map' do
+    let(:map_class)  { Ref::SoftKeyMap }
+    let(:reference_class) { Ref::SoftReference }
+  end
+end

spec/ref/soft_reference_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Ref::SoftReference do
+  describe '#object' do
+    context 'when has not garbage collected objects' do
+      it 'gets the object' do
+        obj = Object.new
+        ref = Ref::SoftReference.new(obj)
+
+        expect(obj).to eq ref.object
+        expect(obj.object_id).to eq ref.referenced_object_id
+      end
+    end
+
+    context 'when has a lot of objects' do
+      # Since we can't reliably control the garbage collector, this is a brute force test.
+      # It might not always fail if the garbage collector and memory allocator don't
+      # cooperate, but it should fail often enough on continuous integration to
+      # hilite any problems. Set the environment variable QUICK_TEST to "true" if you
+      # want to make the tests run quickly.
+      it 'get the correct object' do
+        id_to_ref = {}
+        (ENV["QUICK_TEST"] == "true" ? 1000 : 100000).times do |i|
+          obj = Object.new
+          if id_to_ref.key?(obj.object_id)
+            ref = id_to_ref[obj.object_id]
+            if ref.object
+              fail "soft reference found with a live reference to an object that was not the one it was created with"
+              break
+            end
+          end
+
+          %w(Here are a bunch of objects that are allocated and can then be cleaned up by the garbage collector)
+          id_to_ref[obj.object_id] = Ref::SoftReference.new(obj)
+          if i % 1000 == 0
+            GC.start
+            sleep(0.01)
+          end
+        end
+      end
+    end
+
+    context 'when references are not collected immediately' do
+      it "the object can't be nil" do
+        ref = Ref::SoftReference.new(Object.new)
+        9.times{ arr = %w(allocate some memory on the heap); arr *= 100; GC.start }
+        expect(ref.object).to_not be_nil
+      end
+    end
+  end
+
+  describe '#inspect' do
+    context 'when GC is called' do
+      it 'inspects not be nil' do
+        ref = Ref::SoftReference.new(Object.new)
+        expect(ref.inspect).to_not be_nil
+        GC.start
+        GC.start
+        expect(ref.inspect).to_not be_nil
+      end
+    end
+  end
+end

spec/ref/soft_value_map_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe Ref::SoftValueMap do
-  it_behaves_like 'a reference key map' do
-    let(:map_class)       { Ref::SoftValueMap }
+  it_behaves_like 'a reference value map' do
+    let(:map_class)  { Ref::SoftValueMap }
     let(:reference_class) { Ref::SoftReference }
   end
 end

spec/ref/weak_key_map_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Ref::WeakKeyMap do
+  it_behaves_like 'a reference key map' do
+    let(:map_class)  { Ref::WeakKeyMap }
+    let(:reference_class) { Ref::WeakReference }
+  end
+end

spec/ref/weak_reference_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Ref::WeakReference do
+  describe '#object' do
+    context 'when has not garbage collected objects' do
+      it 'gets the object' do
+        obj = Object.new
+        ref_1 = Ref::WeakReference.new(obj)
+        ref_2 = Ref::WeakReference.new(obj)
+
+        expect(obj).to eq ref_1.object
+        expect(obj.object_id).to eq ref_1.referenced_object_id
+        expect(obj).to eq ref_2.object
+        expect(obj.object_id).to eq ref_2.referenced_object_id
+      end
+    end
+
+    context 'when has a lot of objects' do
+      # Since we can't reliably control the garbage collector, this is a brute force test.
+      # It might not always fail if the garbage collector and memory allocator don't
+      # cooperate, but it should fail often enough on continuous integration to
+      # hilite any problems. Set the environment variable QUICK_TEST to "true" if you
+      # want to make the tests run quickly.
+      it 'get the correct object' do
+        id_to_ref = {}
+        (ENV["QUICK_TEST"] == "true" ? 1000 : 100000).times do |i|
+          obj = Object.new
+          if id_to_ref.key?(obj.object_id)
+            ref = id_to_ref[obj.object_id]
+            if ref.object
+              fail "weak reference found with a live reference to an object that was not the one it was created with"
+              break
+            end
+          end
+          %w(Here are a bunch of objects that are allocated and can then be cleaned up by the garbage collector)
+          id_to_ref[obj.object_id] = Ref::WeakReference.new(obj)
+          if i % 1000 == 0
+            GC.start
+            sleep(0.01)
+          end
+        end
+      end
+    end
+  end
+
+  describe '#inspect' do
+    context 'when GC is called' do
+      it 'inspects not be nil' do
+        ref = Ref::SoftReference.new(Object.new)
+        expect(ref.inspect).to_not be_nil
+        GC.start
+        GC.start
+        expect(ref.inspect).to_not be_nil
+      end
+    end
+  end
+end

spec/ref/weak_value_map_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Ref::WeakValueMap do
+  it_behaves_like 'a reference value map' do
+    let(:map_class)  { Ref::WeakValueMap }
+    let(:reference_class) { Ref::WeakReference }
+  end
+end

test/mock.rb renamed to spec/shared/mock.rb

@@ -1,66 +1,155 @@
 require 'spec_helper'
 
 shared_examples 'a reference key map' do
-
   let(:value_1)  { 'value 1' }
   let(:value_2)  { 'value 2' }
   let(:value_3)  { 'value 3' }
   let(:key_1)    { Object.new }
   let(:key_2)    { Object.new }
+  let(:key_3)    { Object.new }
   let(:hash)     { map_class.new }
 
   describe 'keeps entries with strong references' do
     specify do
       Ref::Mock.use do
-        hash[key_1] = value_1
-        hash[key_2] = value_2
-        expect(hash[key_1] ).to eq(value_1)
-        expect(hash[key_2] ).to eq(value_2)
+        hash[key_1] = "value 1"
+        hash[key_2] = "value 2"
+        expect(hash[key_1]).to eq "value 1"
+        expect(hash[key_2]).to eq "value 2"
       end
     end
   end
 
   describe 'removes entries that have been garbage collected' do
     specify do
       Ref::Mock.use do
-        hash['key 1'] = value_1
-        hash['key 2'] = value_2
-        expect(hash['key 1']).to eq(value_1)
-        expect(hash['key 2']).to eq(value_2)
-        Ref::Mock.gc(value_2)
-        expect(value_1).to eq(value_1)
-        expect(hash['key 2']).to be_nil
+        hash[key_1] = value_1
+        hash[key_2] = value_2
+        expect(hash[key_1]).to eq(value_1)
+        expect(hash[key_2]).to eq(value_2)
+        Ref::Mock.gc(key_2)
+        expect(hash[key_1]).to eq(value_1)
+        expect(hash[key_2]).to be_nil
       end
     end
   end
 
   describe 'can clear the map' do
     specify do
-      hash['key 1'] = value_1
-      hash['key 2'] = value_2
-      hash.clear
-      expect(hash['key 1']).to be_nil
-      expect(hash['key 2']).to be_nil
+      Ref::Mock.use do
+        hash[key_1] = value_1
+        hash[key_2] = value_2
+        hash.clear
+        expect(hash[key_1]).to be_nil
+        expect(hash[key_2]).to be_nil
+      end
     end
   end
 
   describe 'can delete entries' do
     specify do
-      hash['key 1'] = value_1
-      hash['key 2'] = value_2
-      expect(hash.delete('key 3')).to be_nil
-      expect(hash.delete('key 1')).to eq(value_1)
-      expect(hash['key 1']).to be_nil
+      Ref::Mock.use do
+        hash[key_1] = value_1
+        hash[key_2] = value_2
+        Ref::Mock.gc(key_2)
+        expect(hash.delete(key_2)).to be_nil
+        expect(hash.delete(key_1)).to eq(value_1)
+        expect(hash[key_1]).to be_nil
+      end
     end
   end
 
   describe 'can merge in another hash' do
     specify do
-      hash['key 1'] = value_1
-      hash['key 2'] = value_2
-      hash.merge!("key 3" => value_3)
-      expect(hash['key 1']).to be_nil
+      Ref::Mock.use do
+        hash[key_1] = value_1
+        hash[key_2] = value_2
+        hash.merge!(key_3 => value_3)
+
+        expect(hash[key_2]).to eq 'value 2'
+        expect(hash[key_1]).to eq value_1
+
+        Ref::Mock.gc(key_2)
+
+        expect(hash[key_2]).to be_nil
+        expect(hash[key_1]).to eq value_1
+        expect(hash[key_3]).to eq value_3
+      end
+    end
+  end
 
+  describe 'can get all keys' do
+    specify do
+      Ref::Mock.use do
+        hash[key_1] = value_1
+        hash[key_2] = value_2
+        hash[key_3] = value_3
+        expect([key_1, key_2, key_3] - hash.keys).to eq []
+        Ref::Mock.gc(key_2)
+        expect([key_1, key_2, key_3] - hash.keys).to eq [key_2]
+      end
+    end
+  end
+
+  describe 'can turn into an array' do
+    specify do
+      Ref::Mock.use do
+        hash[key_1] = value_1
+        hash[key_2] = value_2
+        hash[key_3] = value_3
+        order = lambda{|a,b| a.last <=> b.last}
+        expect([[key_1, "value 1"], [key_2, "value 2"], [key_3, "value 3"]].sort(&order)).to eq hash.to_a.sort(&order)
+        Ref::Mock.gc(key_2)
+        expect([[key_1, "value 1"], [key_3, "value 3"]].sort(&order)).to eq hash.to_a.sort(&order)
+      end
+    end
+  end
+
+  describe 'can interate over all entries' do
+    specify do
+      Ref::Mock.use do
+        hash[key_1] = value_1
+        hash[key_2] = value_2
+        hash[key_3] = value_3
+        keys = []
+        values = []
+        hash.each{|k,v| keys << k; values << v}
+        expect([key_1, key_2, key_3] - keys).to eq []
+        expect(["value 1", "value 2", "value 3"]).to eq values.sort
+        Ref::Mock.gc(key_2)
+        keys = []
+        values = []
+        hash.each{|k,v| keys << k; values << v}
+        expect([key_1, key_2, key_3] - keys).to eq [key_2]
+        expect(["value 1", "value 3"]).to eq values.sort
+      end
+    end
+  end
+
+  describe 'size' do
+    specify do
+      Ref::Mock.use do
+        hash = map_class.new
+        expect(hash.empty?).to eq true
+        expect(hash.size).to eq 0
+        key_1 = Object.new
+        key_2 = Object.new
+        hash[key_1] = "value 1"
+        hash[key_2] = "value 2"
+        expect(hash.size).to eq 2
+        Ref::Mock.gc(key_2)
+        expect(hash.empty?).to eq false
+        expect(hash.size).to eq 1
+      end
+    end
+  end
+
+  describe 'inspect' do
+    specify do
+      Ref::Mock.use do
+        hash[Object.new] = "value 1"
+        expect(hash.inspect).to_not be_nil
+      end
     end
   end
 end