Atomic specs now defined by share_examples_for

wip: Updated atomic_spec to support platform-specific testing.

Author: jdantonio

Rakefile

@@ -2,6 +2,7 @@ require 'rake'
 require 'bundler/gem_tasks'
 require 'rspec'
 require 'rspec/core/rake_task'
+require 'fileutils'
 
 require_relative 'lib/extension_helper'
 
@@ -20,9 +21,10 @@ end
 
 desc 'Clean up build artifacts'
 task :clean do
-  rm_rf 'pkg/classes'
-  rm_f  'lib/*.jar'
-  rm_rf '**/*.{o,so,bundle}'
+  rm_rf './pkg/classes'
+  rm_f  Dir.glob('./lib/*.jar')
+  rm_f  Dir.glob('./lib/*.{o,so,bundle}')
+  rm_rf './tmp'
 end
 
 if defined?(JRUBY_VERSION)
@@ -46,7 +48,7 @@ if defined?(JRUBY_VERSION)
 
   task :compile_java => :jar
 
-elsif use_c_extensions?
+elsif Concurrent.use_c_extensions?
 
   EXTENSION_NAME = 'concurrent_cruby'
 
@@ -76,9 +78,9 @@ RSpec::Core::RakeTask.new(:travis_spec) do |t|
 end
 
 if defined?(JRUBY_VERSION)
-  task :default => [:compile_java, :travis_spec]
-elsif use_c_extensions?
-  task :default => [:compile_c, :travis_spec]
+  task :default => [:clean, :compile_java, :travis_spec]
+elsif Concurrent.use_c_extensions?
+  task :default => [:clean, :compile_c, :travis_spec]
 else
   task :default => [:clean, :travis_spec]
 end

ext/extconf.rb

@@ -5,7 +5,7 @@
 
 if defined?(JRUBY_VERSION)
   puts 'JRuby detected. Pure Java optimizations will be used.'
-elsif ! use_c_extensions?
+elsif ! Concurrent.use_c_extensions?
   puts 'C optimizations are only supported on MRI 2.0 and above.'
 else
 

lib/extension_helper.rb

@@ -1,7 +1,9 @@
 require 'rbconfig'
 
-def use_c_extensions?
-  host_os = RbConfig::CONFIG['host_os']
-  ruby_name = RbConfig::CONFIG['ruby_install_name']
-  (ruby_name =~ /^ruby$/i || host_os =~ /mswin32/i || host_os =~ /mingw32/i) && RUBY_VERSION >= '2.0'
+module Concurrent
+  def self.use_c_extensions?
+    host_os = RbConfig::CONFIG['host_os']
+    ruby_name = RbConfig::CONFIG['ruby_install_name']
+    (ruby_name =~ /^ruby$/i || host_os =~ /mswin32/i || host_os =~ /mingw32/i) && RUBY_VERSION >= '2.0'
+  end
 end

spec/concurrent/atomic_spec.rb

@@ -1,131 +1,169 @@
 require 'spec_helper'
 
-module Concurrent
+share_examples_for :atomic do
 
-  describe Atomic do
+  specify :test_construct do
+    atomic = described_class.new
+    atomic.value.should be_nil
 
-    specify :test_construct do
-      atomic = Atomic.new
-      atomic.value.should be_nil
+    atomic = described_class.new(0)
+    atomic.value.should eq 0
+  end
 
-      atomic = Atomic.new(0)
-      atomic.value.should eq 0
-    end
+  specify :test_value do
+    atomic = described_class.new(0)
+    atomic.value = 1
 
-    specify :test_value do
-      atomic = Atomic.new(0)
-      atomic.value = 1
+    atomic.value.should eq 1
+  end
 
-      atomic.value.should eq 1
-    end
+  specify :test_update do
+    # use a number outside JRuby's fixnum cache range, to ensure identity is preserved
+    atomic = described_class.new(1000)
+    res = atomic.update {|v| v + 1}
 
-    specify :test_update do
-      # use a number outside JRuby's fixnum cache range, to ensure identity is preserved
-      atomic = Atomic.new(1000)
-      res = atomic.update {|v| v + 1}
+    atomic.value.should eq 1001
+    res.should eq 1001
+  end
 
-      atomic.value.should eq 1001
-      res.should eq 1001
-    end
+  specify :test_try_update do
+    # use a number outside JRuby's fixnum cache range, to ensure identity is preserved
+    atomic = described_class.new(1000)
+    res = atomic.try_update {|v| v + 1}
 
-    specify :test_try_update do
-      # use a number outside JRuby's fixnum cache range, to ensure identity is preserved
-      atomic = Atomic.new(1000)
-      res = atomic.try_update {|v| v + 1}
+    atomic.value.should eq 1001
+    res.should eq 1001
+  end
 
-      atomic.value.should eq 1001
-      res.should eq 1001
-    end
+  specify :test_swap do
+    atomic = described_class.new(1000)
+    res = atomic.swap(1001)
 
-    specify :test_swap do
-      atomic = Atomic.new(1000)
-      res = atomic.swap(1001)
+    atomic.value.should eq 1001
+    res.should eq 1000
+  end
 
-      atomic.value.should eq 1001
-      res.should eq 1000
-    end
+  specify :test_try_update_fails do
+    # use a number outside JRuby's fixnum cache range, to ensure identity is preserved
+    atomic = described_class.new(1000)
+    expect {
+      # assigning within block exploits implementation detail for test
+      atomic.try_update{|v| atomic.value = 1001 ; v + 1}
+    }.to raise_error(Concurrent::Atomic::ConcurrentUpdateError)
+  end
 
-    specify :test_try_update_fails do
-      # use a number outside JRuby's fixnum cache range, to ensure identity is preserved
-      atomic = Atomic.new(1000)
-      expect {
-        # assigning within block exploits implementation detail for test
-        atomic.try_update{|v| atomic.value = 1001 ; v + 1}
-      }.to raise_error(Concurrent::Atomic::ConcurrentUpdateError)
-    end
+  specify :test_update_retries do
+    tries = 0
+    # use a number outside JRuby's fixnum cache range, to ensure identity is preserved
+    atomic = described_class.new(1000)
+    # assigning within block exploits implementation detail for test
+    atomic.update{|v| tries += 1 ; atomic.value = 1001 ; v + 1}
 
-    specify :test_update_retries do
-      tries = 0
-      # use a number outside JRuby's fixnum cache range, to ensure identity is preserved
-      atomic = Atomic.new(1000)
-      # assigning within block exploits implementation detail for test
-      atomic.update{|v| tries += 1 ; atomic.value = 1001 ; v + 1}
+    tries.should eq 2
+  end
+
+  specify :test_numeric_cas do
+    atomic = described_class.new(0)
 
-      tries.should eq 2
+    # 9-bit idempotent Fixnum (JRuby)
+    max_8 = 2**256 - 1
+    min_8 = -(2**256)
+
+    atomic.set(max_8)
+    max_8.upto(max_8 + 2) do |i|
+      atomic.compare_and_swap(i, i+1).should be_true, "CAS failed for numeric #{i} => #{i + 1}"
     end
 
-    specify :test_numeric_cas do
-      atomic = Atomic.new(0)
+    atomic.set(min_8)
+    min_8.downto(min_8 - 2) do |i|
+      atomic.compare_and_swap(i, i-1).should be_true, "CAS failed for numeric #{i} => #{i - 1}"
+    end
 
-      # 9-bit idempotent Fixnum (JRuby)
-      max_8 = 2**256 - 1
-      min_8 = -(2**256)
+    # 64-bit idempotent Fixnum (MRI, Rubinius)
+    max_64 = 2**62 - 1
+    min_64 = -(2**62)
 
-      atomic.set(max_8)
-      max_8.upto(max_8 + 2) do |i|
-        atomic.compare_and_swap(i, i+1).should be_true, "CAS failed for numeric #{i} => #{i + 1}"
-      end
+    atomic.set(max_64)
+    max_64.upto(max_64 + 2) do |i|
+      atomic.compare_and_swap(i, i+1).should be_true, "CAS failed for numeric #{i} => #{i + 1}"
+    end
 
-      atomic.set(min_8)
-      min_8.downto(min_8 - 2) do |i|
-        atomic.compare_and_swap(i, i-1).should be_true, "CAS failed for numeric #{i} => #{i - 1}"
-      end
+    atomic.set(min_64)
+    min_64.downto(min_64 - 2) do |i|
+      atomic.compare_and_swap(i, i-1).should be_true, "CAS failed for numeric #{i} => #{i - 1}"
+    end
 
-      # 64-bit idempotent Fixnum (MRI, Rubinius)
-      max_64 = 2**62 - 1
-      min_64 = -(2**62)
+    ## 64-bit overflow into Bignum (JRuby)
+    max_64 = 2**63 - 1
+    min_64 = (-2**63)
 
-      atomic.set(max_64)
-      max_64.upto(max_64 + 2) do |i|
-        atomic.compare_and_swap(i, i+1).should be_true, "CAS failed for numeric #{i} => #{i + 1}"
-      end
+    atomic.set(max_64)
+    max_64.upto(max_64 + 2) do |i|
+      atomic.compare_and_swap(i, i+1).should be_true, "CAS failed for numeric #{i} => #{i + 1}"
+    end
 
-      atomic.set(min_64)
-      min_64.downto(min_64 - 2) do |i|
-        atomic.compare_and_swap(i, i-1).should be_true, "CAS failed for numeric #{i} => #{i - 1}"
-      end
+    atomic.set(min_64)
+    min_64.downto(min_64 - 2) do |i|
+      atomic.compare_and_swap(i, i-1).should be_true, "CAS failed for numeric #{i} => #{i - 1}"
+    end
 
-      ## 64-bit overflow into Bignum (JRuby)
-      max_64 = 2**63 - 1
-      min_64 = (-2**63)
+    # non-idempotent Float (JRuby, Rubinius, MRI < 2.0.0 or 32-bit)
+    atomic.set(1.0 + 0.1)
+    atomic.compare_and_set(1.0 + 0.1, 1.2).should be_true, "CAS failed for #{1.0 + 0.1} => 1.2"
 
-      atomic.set(max_64)
-      max_64.upto(max_64 + 2) do |i|
-        atomic.compare_and_swap(i, i+1).should be_true, "CAS failed for numeric #{i} => #{i + 1}"
-      end
+    # Bignum
+    atomic.set(2**100)
+    atomic.compare_and_set(2**100, 0).should be_true, "CAS failed for #{2**100} => 0"
 
-      atomic.set(min_64)
-      min_64.downto(min_64 - 2) do |i|
-        atomic.compare_and_swap(i, i-1).should be_true, "CAS failed for numeric #{i} => #{i - 1}"
-      end
+    # Rational
+    require 'rational' unless ''.respond_to? :to_r
+    atomic.set(Rational(1,3))
+    atomic.compare_and_set(Rational(1,3), 0).should be_true, "CAS failed for #{Rational(1,3)} => 0"
 
-      # non-idempotent Float (JRuby, Rubinius, MRI < 2.0.0 or 32-bit)
-      atomic.set(1.0 + 0.1)
-      atomic.compare_and_set(1.0 + 0.1, 1.2).should be_true, "CAS failed for #{1.0 + 0.1} => 1.2"
+    # Complex
+    require 'complex' unless ''.respond_to? :to_c
+    atomic.set(Complex(1,2))
+    atomic.compare_and_set(Complex(1,2), 0).should be_true, "CAS failed for #{Complex(1,2)} => 0"
+  end
+end
+
+module Concurrent
 
-      # Bignum
-      atomic.set(2**100)
-      atomic.compare_and_set(2**100, 0).should be_true, "CAS failed for #{2**100} => 0"
+  describe Atomic do
+    it_should_behave_like :atomic
+  end
 
-      # Rational
-      require 'rational' unless ''.respond_to? :to_r
-      atomic.set(Rational(1,3))
-      atomic.compare_and_set(Rational(1,3), 0).should be_true, "CAS failed for #{Rational(1,3)} => 0"
+  if defined? Concurrent::CAtomic
+    describe CAtomic do
+      it_should_behave_like :atomic
+    end
+  elsif defined? Concurrent::JavaAtomic
+    describe JavaAtomic do
+      it_should_behave_like :atomic
+    end
+  elsif defined? Concurrent::RbxAtomic
+    describe RbxAtomic do
+      it_should_behave_like :atomic
+    end
+  end
 
-      # Complex
-      require 'complex' unless ''.respond_to? :to_c
-      atomic.set(Complex(1,2))
-      atomic.compare_and_set(Complex(1,2), 0).should be_true, "CAS failed for #{Complex(1,2)} => 0"
+  describe Atomic do
+    if TestHelpers.use_c_extensions?
+      it 'inherits from CAtomic' do
+        Atomic.ancestors.should include(CAtomic)
+      end
+    elsif TestHelpers.jruby?
+      it 'inherits from JavaAtomic' do
+        Atomic.ancestors.should include(JavaAtomic)
+      end
+    elsif TestHelpers.rbx?
+      it 'inherits from RbxAtomic' do
+        Atomic.ancestors.should include(RbxAtomic)
+      end
+    else
+      it 'inherits from MutexAtomic' do
+        Atomic.ancestors.should include(MutexAtomic)
+      end
     end
   end
 end

spec/support/example_group_extensions.rb

@@ -1,4 +1,5 @@
 require 'rbconfig'
+require_relative '../../lib/extension_helper.rb'
 
 module Concurrent
   module TestHelpers
@@ -22,6 +23,10 @@ def rbx?
       RbConfig::CONFIG['ruby_install_name']=~ /^rbx$/i
     end
 
+    def use_c_extensions?
+      Concurrent.use_c_extensions? # from extension_helper.rb
+    end
+
     def do_no_reset!
       @do_not_reset = true
     end