Merge pull request #32 from pedroandrade/migrate-to-rspec

Migrate to RSpec

Author: lucasallan

Gemfile

@@ -9,7 +9,7 @@ end
 
 group :testing do
   gem 'test-unit', '~> 3.0.9'
-  #gem 'rspec', '~> 3.0.0'
+  gem 'rspec', '~> 3.1.0'
   #gem 'simplecov', '~> 0.8.2', :require => false
   gem 'coveralls', '~> 0.7.3', :require => false
 end

Rakefile

@@ -3,20 +3,22 @@ require 'rake/testtask'
 require 'rubygems/package_task'
 require File.expand_path('../lib/ref', __FILE__)
 
-desc 'Default: run unit tests.'
-task :default => :test
+begin
+  require 'rspec'
+  require 'rspec/core/rake_task'
 
-desc 'RVM likes to call it tests'
-task :tests => :test
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.rspec_opts = '--color --backtrace --format documentation'
+  end
 
-Rake::TestTask.new do |t|
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.warning = true
-  t.verbose = true
+  task :default => :spec
+rescue LoadError
+  puts 'Error loading Rspec rake tasks, probably building the gem...'
 end
 
 
+spec = eval(File.read(File.expand_path('../ref.gemspec', __FILE__)))
+
 GEM_NAME       = 'ref'
 EXTENSION_NAME = 'extension'
 JAVA_EXT_NAME  = 'ref_ext'

spec/ref/mock_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Ref::Mock do
+
+  context 'gc with argument' do
+    specify do
+      Ref::Mock.use do
+        obj_1 = Object.new
+        obj_2 = Object.new
+
+        ref_1 = Ref::WeakReference.new(obj_1)
+        ref_2 = Ref::WeakReference.new(obj_2)
+
+        Ref::Mock.gc(obj_1)
+
+        expect(ref_1.object).to be_nil
+        expect(ref_2.object).to equal(obj_2)
+      end
+    end
+  end
+
+  context 'gc with no argument' do
+    specify do
+      Ref::Mock.use do
+        obj_1 = Object.new
+        obj_2 = Object.new
+
+        ref_1 = Ref::WeakReference.new(obj_1)
+        ref_2 = Ref::WeakReference.new(obj_2)
+
+        Ref::Mock.gc
+
+        expect(ref_1.object).to be_nil
+        expect(ref_2.object).to be_nil
+      end
+    end
+  end
+
+end

spec/ref/reference_queue_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Ref::ReferenceQueue do
+
+  let(:queue) { Ref::ReferenceQueue.new }
+  let(:obj_1) { Object.new }
+  let(:obj_2) { Object.new }
+  let(:ref_1) { Ref::WeakReference.new(obj_1) }
+  let(:ref_2) { Ref::WeakReference.new(obj_2) }
+
+  describe '#push' do
+    context 'when the queue is empty' do
+      it { expect(queue.size).to be(0) }
+      it { expect(queue).to be_empty }
+    end
+
+    context 'when the queue is not empty' do
+      before do
+        queue.push(ref_1)
+        queue.push(ref_2)
+      end
+
+      it { expect(queue.size).to be(2) }
+      it { expect(queue).to_not be_empty }
+    end
+  end
+
+  describe '#shift' do
+    context 'when the queue is not empty' do
+      before do
+        queue.push(ref_1)
+        queue.push(ref_2)
+      end
+      it { expect(queue.shift).to be(ref_1) }
+    end
+
+    context 'when the queue is empty' do
+      it { expect(queue.shift).to be_nil }
+    end
+  end
+
+  describe '#pop' do
+    context 'when the queue is not empty' do
+      before do
+        queue.push(ref_1)
+        queue.push(ref_2)
+      end
+
+      it { expect(queue.pop).to be(ref_2) }
+    end
+    context 'when the queue is empty' do
+      it { expect(queue.pop).to be_nil }
+    end
+  end
+
+  context 'references are added immediately if the_object has been collected' do
+    specify do
+      Ref::Mock.use do
+        ref = Ref::WeakReference.new(obj_1)
+        Ref::Mock.gc(obj_1)
+        queue.monitor(ref)
+
+        expect(ref).to equal(queue.shift)
+      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

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

spec/ref/strong_reference_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Ref::StrongReference do
+  let(:obj) { Object.new }
+  let(:ref) { Ref::StrongReference.new(obj) }
+
+  context '#object' do
+    it { expect(obj).to equal(ref.object) }
+    it { expect(obj.object_id).to equal(ref.referenced_object_id) }
+  end
+
+  context '#inspect' do
+    it { expect(ref.inspect).to_not be_empty }
+  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