Merge pull request #34 from kares/fix-tests

cleanup & fix tests + make SynchronizedDelegator work on 1.8

Author: headius

.travis.yml

@@ -2,9 +2,23 @@ language: ruby
 rvm:
   - jruby-18mode
   - jruby-19mode
-  - rbx-18mode
-  - rbx-19mode
+  - rbx-2
   - 1.8.7
-  - 1.9.2
   - 1.9.3
   - 2.0.0
+  - 2.1.0
+jdk: # for JRuby only
+  - openjdk7
+  - oraclejdk8
+matrix:
+  exclude:
+    - rvm: rbx-2
+      jdk: oraclejdk8
+    - rvm: 1.8.7
+      jdk: oraclejdk8
+    - rvm: 1.9.3
+      jdk: oraclejdk8
+    - rvm: 2.0.0
+      jdk: oraclejdk8
+    - rvm: 2.1.0
+      jdk: oraclejdk8

lib/thread_safe/synchronized_delegator.rb

@@ -1,35 +1,51 @@
+require 'delegate'
+
 # This class provides a trivial way to synchronize all calls to a given object
-# by wrapping it with a Delegator that performs Mutex#lock/unlock calls around
-# the delegated #send. Example:
+# by wrapping it with a `Delegator` that performs `Mutex#lock/unlock` calls
+# around the delegated `#send`. Example:
 #
 #   array = [] # not thread-safe on many impls
-#   array = MutexedDelegator.new(array) # thread-safe
+#   array = SynchronizedDelegator.new([]) # thread-safe
 #
-# A simple Mutex provides a very coarse-grained way to synchronize a given
+# A simple `Mutex` provides a very coarse-grained way to synchronize a given
 # object, in that it will cause synchronization for methods that have no
 # need for it, but this is a trivial way to get thread-safety where none may
 # exist currently on some implementations.
 #
 # This class is currently being considered for inclusion into stdlib, via
 # https://bugs.ruby-lang.org/issues/8556
+class SynchronizedDelegator < SimpleDelegator
 
-require 'delegate'
+  def initialize(obj)
+    __setobj__(obj)
+    @mutex = Mutex.new
+  end
 
-unless defined?(SynchronizedDelegator)
-  class SynchronizedDelegator < SimpleDelegator
-    def initialize(*)
+  def method_missing(method, *args, &block)
+    mutex = @mutex
+    begin
+      mutex.lock
       super
-      @mutex = Mutex.new
+    ensure
+      mutex.unlock
     end
+  end
 
-    def method_missing(m, *args, &block)
-      begin
-        mutex = @mutex
-	mutex.lock
-	super
-      ensure
-	mutex.unlock
+  # Work-around for 1.8 std-lib not passing block around to delegate.
+  # @private
+  def method_missing(method, *args, &block)
+    mutex = @mutex
+    begin
+      mutex.lock
+      target = self.__getobj__
+      if target.respond_to?(method)
+        target.__send__(method, *args, &block)
+      else
+        super(method, *args, &block)
       end
+    ensure
+      mutex.unlock
     end
-  end
-end
+  end if RUBY_VERSION[0, 3] == '1.8'
+
+end unless defined?(SynchronizedDelegator)

test/test_cache_loops.rb

@@ -165,7 +165,7 @@ def compute_if_absent_and_present(opts = {})
         cache.compute_if_absent(key)  { acc += 1; 1 }
       end
     RUBY_EVAL
-    do_thread_loop(:compute_if_absent_and_present, code, {:loop_count => 5, :prelude => prelude}.merge(opts)) do |result, cache, options, keys|
+    do_thread_loop(__method__, code, {:loop_count => 5, :prelude => prelude}.merge(opts)) do |result, cache, options, keys|
       stored_sum       = 0
       stored_key_count = 0
       keys.each do |k|
@@ -188,7 +188,7 @@ def add_remove(opts = {})
         acc -= 1 if cache.delete_pair(key, key)
       end
     RUBY_EVAL
-    do_thread_loop(:add_remove, code, {:loop_count => 5, :prelude => prelude}.merge(opts)) do |result, cache, options, keys|
+    do_thread_loop(__method__, code, {:loop_count => 5, :prelude => prelude}.merge(opts)) do |result, cache, options, keys|
       assert_all_key_mappings_exist(cache, keys, false)
       assert_equal(cache.size, sum(result))
     end
@@ -207,7 +207,7 @@ def add_remove_via_compute(opts = {})
         end
       end
     RUBY_EVAL
-    do_thread_loop(:add_remove_via_compute, code, {:loop_count => 5, :prelude => prelude}.merge(opts)) do |result, cache, options, keys|
+    do_thread_loop(__method__, code, {:loop_count => 5, :prelude => prelude}.merge(opts)) do |result, cache, options, keys|
       assert_all_key_mappings_exist(cache, keys, false)
       assert_equal(cache.size, sum(result))
     end
@@ -222,7 +222,7 @@ def add_remove_via_compute_if_absent_present(opts = {})
         cache.compute_if_present(key) { acc -= 1; nil }
       end
     RUBY_EVAL
-    do_thread_loop(:add_remove_via_compute_if_absent_present, code, {:loop_count => 5, :prelude => prelude}.merge(opts)) do |result, cache, options, keys|
+    do_thread_loop(__method__, code, {:loop_count => 5, :prelude => prelude}.merge(opts)) do |result, cache, options, keys|
       assert_all_key_mappings_exist(cache, keys, false)
       assert_equal(cache.size, sum(result))
     end
@@ -237,7 +237,7 @@ def add_remove_indiscriminate(opts = {})
         acc -= 1 if cache.delete(key)
       end
     RUBY_EVAL
-    do_thread_loop(:add_remove, code, {:loop_count => 5, :prelude => prelude}.merge(opts)) do |result, cache, options, keys|
+    do_thread_loop(__method__, code, {:loop_count => 5, :prelude => prelude}.merge(opts)) do |result, cache, options, keys|
       assert_all_key_mappings_exist(cache, keys, false)
       assert_equal(cache.size, sum(result))
     end
@@ -248,7 +248,7 @@ def count_up(opts = {})
       v = cache[key]
       acc += 1 if cache.replace_pair(key, v, v + 1)
     RUBY_EVAL
-    do_thread_loop(:count_up, code, {:loop_count => 5, :cache_setup => ZERO_VALUE_CACHE_SETUP}.merge(opts)) do |result, cache, options, keys|
+    do_thread_loop(__method__, code, {:loop_count => 5, :cache_setup => ZERO_VALUE_CACHE_SETUP}.merge(opts)) do |result, cache, options, keys|
       assert_count_up(result, cache, options, keys)
     end
   end
@@ -325,7 +325,6 @@ def do_thread_loop(name, code, options = {}, &block)
   def run_thread_loop(meth, keys, options)
     cache   = options[:cache_setup].call(options, keys)
     barrier = ThreadSafe::Test::Barrier.new(options[:thread_count])
-    t       = Time.now
     result = (1..options[:thread_count]).map do
       Thread.new do
         setup_sync_and_start_loop(meth, cache, keys, barrier, options[:loop_count])

test/test_helper.rb

@@ -2,7 +2,7 @@
 
 if defined?(JRUBY_VERSION) && ENV['TEST_NO_UNSAFE']
   # to be used like this: rake test TEST_NO_UNSAFE=true
-  require 'test/package.jar'
+  load 'test/package.jar'
   java_import 'thread_safe.SecurityManager'
   manager = SecurityManager.new
 

test/test_synchronized_delegator.rb

@@ -2,41 +2,83 @@
 require 'thread_safe/synchronized_delegator.rb'
 
 class TestSynchronizedDelegator < Test::Unit::TestCase
+
   def test_wraps_array
-    ary = []
-    sync_ary = SynchronizedDelegator.new(ary)
+    sync_array = SynchronizedDelegator.new(array = [])
+
+    array << 1
+    assert_equal 1, sync_array[0]
 
-    ary << 1
-    assert_equal 1, sync_ary[0]
+    sync_array << 2
+    assert_equal 2, array[1]
   end
 
   def test_synchronizes_access
-    ary = []
-    sync_ary = SynchronizedDelegator.new(ary)
+    t1_continue, t2_continue = false, false
 
-    t1_continue = false
-    t2_continue = false
+    hash = Hash.new do |hash, key|
+      t2_continue = true
+      unless hash.find { |e| e[1] == key.to_s } # just to do something
+        hash[key] = key.to_s
+        Thread.pass until t1_continue
+      end
+    end
+    sync_hash = SynchronizedDelegator.new(hash)
+    sync_hash[1] = 'egy'
 
     t1 = Thread.new do
-      sync_ary << 1
-      sync_ary.each do
+      sync_hash[2] = 'dva'
+      sync_hash[3] # triggers t2_continue
+    end
+
+    t2 = Thread.new do
+      Thread.pass until t2_continue
+      sync_hash[4] = '42'
+    end
+
+    sleep(0.05) # sleep some to allow threads to boot
+
+    until t2.status == 'sleep' do
+      Thread.pass
+    end
+
+    assert_equal 3, hash.keys.size
+
+    t1_continue = true
+    t1.join; t2.join
+
+    assert_equal 4, sync_hash.size
+  end
+
+  def test_synchronizes_access_with_block
+    t1_continue, t2_continue = false, false
+
+    sync_array = SynchronizedDelegator.new(array = [])
+
+    t1 = Thread.new do
+      sync_array << 1
+      sync_array.each do
         t2_continue = true
         Thread.pass until t1_continue
       end
     end
 
     t2 = Thread.new do
+      # sleep(0.01)
       Thread.pass until t2_continue
-      sync_ary << 2
+      sync_array << 2
     end
 
-    Thread.pass until t2.status == 'sleep'
-    assert_equal 1, ary.size
+    until t2.status == 'sleep' || t2.status == false do
+      Thread.pass
+    end
+
+    assert_equal 1, array.size
 
     t1_continue = true
-    t1.join
-    t2.join
+    t1.join; t2.join
 
-    assert_equal 2, sync_ary.size
+    assert_equal [1, 2], array
   end
+
 end

thread_safe.gemspec

@@ -1,5 +1,6 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path('../lib/thread_safe/version', __FILE__)
+$:.push File.expand_path('../lib', __FILE__) unless $:.include?('lib')
+require 'thread_safe/version'
 
 Gem::Specification.new do |gem|
   gem.authors       = ["Charles Oliver Nutter", "thedarkone"]