thread_safe 0.3.5-java → 0.3.6-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fbd202dbf911be29e025cf656ec85fa07024805f
-  data.tar.gz: ece8fcb51b53bea677a7de3bd3729b5a2345e394
+  metadata.gz: a56e33ebbf2000bf9b8ca0f20923d17823dc8fa7
+  data.tar.gz: f8c418f2b9b457bed5cd8afd13f02d139b54e175
 SHA512:
-  metadata.gz: 8262d11575eda01b362dcf1661cfb023e1a6216fdffdfb0e4a47d4f48d0ea87a6d3950af9978d23dd9d85d524bbeef72f8b13b5c12db0bd930886bff2806c0d6
-  data.tar.gz: b1ac9f0689d82854d827dc58009e519518cb57cc25bb3908465322739b9e3f92c6d51e43e5f54fb89dc30ac6efa4136e5884fa6aecabf0b3eb8801fffb283aed
+  metadata.gz: 548447d823cce2404e6b93f2b61388cfeb1faf6093c61527064d4f70653c7978ecf9d9610c81d8ba03da5c821a375b0b3b53dc88acc17b3b0a0034e4167d57ae
+  data.tar.gz: 9cc185a2ff3c32e3cba5c41fee624b6db6140da77d802fdca1fc72aeb380e9298dc7dc4c0a5f4a934fd0058c43923b02c1fc70dda193c55ac81a2eb082930245

data/.rspec

@@ -0,0 +1,2 @@
+--require spec_helper
+--format progress

data/.travis.yml

@@ -1,43 +1,46 @@
+dist: trusty
+sudo: required
 language: ruby
 rvm:
-  - 2.2.0
-  - 2.1.5
-  - 2.1.4
+  - 2.4.0
+  - 2.3.3
+  - 2.2.6
+  - 2.1.9
   - 2.0.0
   - 1.9.3
   - ruby-head
-  - jruby-1.7.18
+  - jruby-9.1.5.0
+  - jruby-1.7.26
   - jruby-head
-  - rbx-2
-jdk: # for JRuby only
+  - rubinius-3
+  - rubinius-2
+jdk:
   - openjdk7
   - oraclejdk8
 matrix:
   exclude:
-    - rvm: 2.2.0
-      jdk: openjdk7
+    - rvm: 2.4.0
       jdk: oraclejdk8
-    - rvm: 2.1.5
-      jdk: openjdk7
+    - rvm: 2.3.3
       jdk: oraclejdk8
-    - rvm: 2.1.4
-      jdk: openjdk7
+    - rvm: 2.2.6
+      jdk: oraclejdk8
+    - rvm: 2.1.9
       jdk: oraclejdk8
     - rvm: 2.0.0
-      jdk: openjdk7
       jdk: oraclejdk8
     - rvm: 1.9.3
-      jdk: openjdk7
       jdk: oraclejdk8
     - rvm: ruby-head
-      jdk: openjdk7
       jdk: oraclejdk8
-    - rvm: rbx-2
-      jdk: openjdk7
+    - rvm: rubinius-3
+      jdk: oraclejdk8
+    - rvm: rubinius-2
       jdk: oraclejdk8
   allow_failures:
+    - rvm: 1.9.3
     - rvm: ruby-head
+    - rvm: jruby-1.7.26
     - rvm: jruby-head
-    - rvm: 1.9.3
-
-script: "rake TESTOPTS='--seed=1'"
+    - rvm: rubinius-2
+script: "bundle exec rake test"

data/Gemfile

@@ -3,9 +3,12 @@ source 'https://rubygems.org'
 gemspec
 
 group :development, :test do
-  gem 'minitest', '~> 5.5.1'
-  gem 'minitest-reporters', '~> 1.0.11'
+  gem 'rspec', '~> 3.2.0'
   gem 'simplecov', '~> 0.9.2', :require => false
+  if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0.0')
+    gem 'term-ansicolor', '~> 1.3.2', :require => false
+    gem 'tins', '~> 1.6.0', :require => false
+  end
   gem 'coveralls', '~> 0.7.11', :require => false
 end
 

data/README.md

@@ -1,9 +1,13 @@
-# Threadsafe
+# Threadsafe (Inactive, code moved to concurrent-ruby gem and repo.)
 
 [![Gem Version](https://badge.fury.io/rb/thread_safe.svg)](http://badge.fury.io/rb/thread_safe) [![Build Status](https://travis-ci.org/ruby-concurrency/thread_safe.svg?branch=master)](https://travis-ci.org/ruby-concurrency/thread_safe) [![Coverage Status](https://img.shields.io/coveralls/ruby-concurrency/thread_safe/master.svg)](https://coveralls.io/r/ruby-concurrency/thread_safe) [![Code Climate](https://codeclimate.com/github/ruby-concurrency/thread_safe.svg)](https://codeclimate.com/github/ruby-concurrency/thread_safe) [![Dependency Status](https://gemnasium.com/ruby-concurrency/thread_safe.svg)](https://gemnasium.com/ruby-concurrency/thread_safe) [![License](https://img.shields.io/badge/license-apache-green.svg)](http://opensource.org/licenses/MIT) [![Gitter chat](http://img.shields.io/badge/gitter-join%20chat%20%E2%86%92-brightgreen.svg)](https://gitter.im/ruby-concurrency/concurrent-ruby)
 
 A collection of thread-safe versions of common core Ruby classes.
 
+__This code base is now part of the concurrent-ruby gem
+at https://github.com/ruby-concurrency/concurrent-ruby.
+The code in this repository is no longer maintained.__
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/Rakefile

@@ -1,5 +1,6 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
+require 'bundler/gem_tasks'
+require 'rspec'
+require 'rspec/core/rake_task'
 
 ## safely load all the rake tasks in the `tasks` directory
 def safe_load(file)
@@ -10,6 +11,7 @@ def safe_load(file)
     puts ex.message
   end
 end
+
 Dir.glob('tasks/**/*.rake').each do |rakefile|
   safe_load rakefile
 end
@@ -17,9 +19,9 @@ end
 task :default => :test
 
 if defined?(JRUBY_VERSION)
-  require "ant"
+  require 'ant'
 
-  directory "pkg/classes"
+  directory 'pkg/classes'
   directory 'pkg/tests'
 
   desc "Clean up build artifacts"
@@ -43,10 +45,10 @@ if defined?(JRUBY_VERSION)
 
   desc "Build test jar"
   task 'test-jar' => 'pkg/tests' do |t|
-    ant.javac :srcdir => 'test/src', :destdir => t.prerequisites.first,
+    ant.javac :srcdir => 'spec/src', :destdir => t.prerequisites.first,
       :source => "1.5", :target => "1.5", :debug => true
 
-    ant.jar :basedir => 'pkg/tests', :destfile => 'test/package.jar', :includes => '**/*.class'
+    ant.jar :basedir => 'pkg/tests', :destfile => 'spec/package.jar', :includes => '**/*.class'
   end
 
   task :package => [ :clean, :compile, :jar, 'test-jar' ]
@@ -55,7 +57,6 @@ else
   task :package
 end
 
-Rake::TestTask.new :test => :package do |t|
-  t.libs << "lib"
-  t.test_files = FileList["test/**/*.rb"]
+RSpec::Core::RakeTask.new :test => :package do |t|
+  t.rspec_opts = '--color --backtrace --tag ~unfinished --seed 1 --format documentation ./spec'
 end

data/lib/thread_safe/cache.rb

@@ -21,8 +21,6 @@ module ThreadSafe
   end
 
   class Cache < ConcurrentCacheBackend
-    KEY_ERROR = defined?(KeyError) ? KeyError : IndexError # there is no KeyError in 1.8 mode
-
     def initialize(options = nil, &block)
       if options.kind_of?(::Hash)
         validate_options_hash!(options)
@@ -138,7 +136,7 @@ module ThreadSafe
 
     private
     def raise_fetch_no_key
-      raise KEY_ERROR, 'key not found'
+      raise KeyError, 'key not found'
     end
 
     def initialize_copy(other)
@@ -152,8 +150,8 @@ module ThreadSafe
     end
 
     def validate_options_hash!(options)
-      if (initial_capacity = options[:initial_capacity]) && (!initial_capacity.kind_of?(Fixnum) || initial_capacity < 0)
-        raise ArgumentError, ":initial_capacity must be a positive Fixnum"
+      if (initial_capacity = options[:initial_capacity]) && (!initial_capacity.kind_of?(0.class) || initial_capacity < 0)
+        raise ArgumentError, ":initial_capacity must be a positive #{0.class}"
       end
       if (load_factor = options[:load_factor]) && (!load_factor.kind_of?(Numeric) || load_factor <= 0 || load_factor > 1)
         raise ArgumentError, ":load_factor must be a number between 0 and 1"

data/lib/thread_safe/mri_cache_backend.rb

@@ -3,15 +3,6 @@ module ThreadSafe
     # We can get away with a single global write lock (instead of a per-instance
     # one) because of the GVL/green threads.
     #
-    # The previous implementation used `Thread.critical` on 1.8 MRI to implement
-    # the 4 composed atomic operations (`put_if_absent`, `replace_pair`,
-    # `replace_if_exists`, `delete_pair`) this however doesn't work for
-    # `compute_if_absent` because on 1.8 the Mutex class is itself implemented
-    # via `Thread.critical` and a call to `Mutex#lock` does not restore the
-    # previous `Thread.critical` value (thus any synchronisation clears the
-    # `Thread.critical` flag and we loose control). This poses a problem as the
-    # provided block might use synchronisation on its own.
-    #
     # NOTE: a neat idea of writing a c-ext to manually perform atomic
     # put_if_absent, while relying on Ruby not releasing a GVL while calling a
     # c-ext will not work because of the potentially Ruby implemented `#hash`

data/lib/thread_safe/synchronized_delegator.rb

@@ -40,21 +40,4 @@ class SynchronizedDelegator < SimpleDelegator
     end
   end
 
-  # Work-around for 1.8 std-lib not passing block around to delegate.
-  # @private
-  def method_missing(method, *args, &block)
-    monitor = @monitor
-    begin
-      monitor.enter
-      target = self.__getobj__
-      if target.respond_to?(method)
-        target.__send__(method, *args, &block)
-      else
-        super(method, *args, &block)
-      end
-    ensure
-      monitor.exit
-    end
-  end if RUBY_VERSION[0, 3] == '1.8'
-
 end unless defined?(SynchronizedDelegator)

data/lib/thread_safe/util/atomic_reference.rb

@@ -9,7 +9,6 @@ module ThreadSafe
           require 'atomic'
           defined?(Atomic::InternalReference) ? Atomic::InternalReference : Atomic
         rescue LoadError, NameError
-          require 'thread' # get Mutex on 1.8
           class FullLockingAtomicReference
             def initialize(value = nil)
               @___mutex = Mutex.new

data/lib/thread_safe/version.rb

@@ -1,5 +1,5 @@
 module ThreadSafe
-  VERSION = "0.3.5"
+  VERSION = "0.3.6"
 end
 
 # NOTE: <= 0.2.0 used Threadsafe::VERSION

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+require 'simplecov'
+require 'coveralls'
+require 'logger'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+]
+
+SimpleCov.start do
+  project_name 'thread_safe'
+  add_filter '/coverage/'
+  add_filter '/pkg/'
+  add_filter '/spec/'
+  add_filter '/tasks/'
+  add_filter '/yard-template/'
+end
+
+$VERBOSE = nil # suppress our deprecation warnings
+require 'thread_safe'
+
+logger                          = Logger.new($stderr)
+logger.level                    = Logger::WARN
+
+# import all the support files
+Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each { |f| require File.expand_path(f) }
+
+RSpec.configure do |config|
+  #config.raise_errors_for_deprecations!
+  config.order = 'random'
+end

data/spec/support/threads.rb

@@ -0,0 +1 @@
+THREADS = (RUBY_ENGINE == 'ruby' ? 100 : 10)

data/{test/test_helper.rb → spec/support/threadsafe_test.rb}

@@ -1,62 +1,3 @@
-unless defined?(JRUBY_VERSION)
-  require 'simplecov'
-  require 'coveralls'
-
-  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-    SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
-  ]
-
-  SimpleCov.start do
-    project_name 'thread_safe'
-
-    add_filter '/examples/'
-    add_filter '/pkg/'
-    add_filter '/test/'
-    add_filter '/tasks/'
-    add_filter '/yard-template/'
-    add_filter '/yardoc/'
-
-    command_name 'Mintest'
-  end
-end
-
-require 'minitest/autorun'
-
-require 'minitest/reporters'
-Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new(color: true)
-
-require 'thread'
-require 'thread_safe'
-
-THREADS = (RUBY_ENGINE == 'ruby' ? 100 : 10)
-
-if defined?(JRUBY_VERSION) && ENV['TEST_NO_UNSAFE']
-  # to be used like this: rake test TEST_NO_UNSAFE=true
-  load 'test/package.jar'
-  java_import 'thread_safe.SecurityManager'
-  manager = SecurityManager.new
-
-  # Prevent accessing internal classes
-  manager.deny java.lang.RuntimePermission.new("accessClassInPackage.sun.misc")
-  java.lang.System.setSecurityManager manager
-
-  class TestNoUnsafe < Minitest::Test
-    def test_security_manager_is_used
-      begin
-        java_import 'sun.misc.Unsafe'
-        flunk
-      rescue SecurityError
-      end
-    end
-
-    def test_no_unsafe_version_of_chmv8_is_used
-      require 'thread_safe/jruby_cache_backend' # make sure the jar has been loaded
-      assert !Java::OrgJrubyExtThread_safe::JRubyCacheBackendLibrary::JRubyCacheBackend::CAN_USE_UNSAFE_CHM
-    end
-  end
-end
-
 module ThreadSafe
   module Test
     class Latch

data/spec/thread_safe/array_spec.rb

@@ -0,0 +1,18 @@
+module ThreadSafe
+  describe Array do
+    let!(:ary) { described_class.new }
+
+    it 'concurrency' do
+      (1..THREADS).map do |i|
+        Thread.new do
+          1000.times do
+            ary << i
+            ary.each { |x| x * 2 }
+            ary.shift
+            ary.last
+          end
+        end
+      end.map(&:join)
+    end
+  end
+end

data/spec/thread_safe/cache_loops_spec.rb

@@ -0,0 +1,507 @@
+Thread.abort_on_exception = true
+
+module ThreadSafe
+  describe 'CacheTorture' do
+    THREAD_COUNT  = 40
+    KEY_COUNT     = (((2**13) - 2) * 0.75).to_i # get close to the doubling cliff
+    LOW_KEY_COUNT = (((2**8 ) - 2) * 0.75).to_i # get close to the doubling cliff
+
+    INITIAL_VALUE_CACHE_SETUP = lambda do |options, keys|
+      cache         = ThreadSafe::Cache.new
+      initial_value = options[:initial_value] || 0
+      keys.each { |key| cache[key] = initial_value }
+      cache
+    end
+    ZERO_VALUE_CACHE_SETUP = lambda do |options, keys|
+      INITIAL_VALUE_CACHE_SETUP.call(options.merge(:initial_value => 0), keys)
+    end
+
+    DEFAULTS = {
+      key_count:    KEY_COUNT,
+      thread_count: THREAD_COUNT,
+      loop_count:   1,
+      prelude:      '',
+      cache_setup:  lambda { |options, keys| ThreadSafe::Cache.new }
+    }
+
+    LOW_KEY_COUNT_OPTIONS    = {loop_count: 150,     key_count: LOW_KEY_COUNT}
+    SINGLE_KEY_COUNT_OPTIONS = {loop_count: 100_000, key_count: 1}
+
+    it 'concurrency' do
+      code = <<-RUBY_EVAL
+        cache[key]
+        cache[key] = key
+        cache[key]
+        cache.delete(key)
+      RUBY_EVAL
+      do_thread_loop(:concurrency, code)
+    end
+
+    it '#put_if_absent' do
+      do_thread_loop(
+        :put_if_absent, 
+        'acc += 1 unless cache.put_if_absent(key, key)', 
+        key_count: 100_000
+      ) do |result, cache, options, keys|
+        expect_standard_accumulator_test_result(result, cache, options, keys)
+      end
+    end
+
+    it '#compute_put_if_absent' do
+      code = <<-RUBY_EVAL
+        if key.even?
+          cache.compute_if_absent(key) { acc += 1; key }
+        else
+          acc += 1 unless cache.put_if_absent(key, key)
+        end
+      RUBY_EVAL
+      do_thread_loop(:compute_if_absent, code) do |result, cache, options, keys|
+        expect_standard_accumulator_test_result(result, cache, options, keys)
+      end
+    end
+
+    it '#compute_if_absent_and_present' do
+      compute_if_absent_and_present
+      compute_if_absent_and_present(LOW_KEY_COUNT_OPTIONS)
+      compute_if_absent_and_present(SINGLE_KEY_COUNT_OPTIONS)
+    end
+
+    it 'add_remove_to_zero' do
+      add_remove_to_zero
+      add_remove_to_zero(LOW_KEY_COUNT_OPTIONS)
+      add_remove_to_zero(SINGLE_KEY_COUNT_OPTIONS)
+    end
+
+    it 'add_remove_to_zero_via_merge_pair' do
+      add_remove_to_zero_via_merge_pair
+      add_remove_to_zero_via_merge_pair(LOW_KEY_COUNT_OPTIONS)
+      add_remove_to_zero_via_merge_pair(SINGLE_KEY_COUNT_OPTIONS)
+    end
+
+    it 'add_remove' do
+      add_remove
+      add_remove(LOW_KEY_COUNT_OPTIONS)
+      add_remove(SINGLE_KEY_COUNT_OPTIONS)
+    end
+
+    it 'add_remove_via_compute' do
+      add_remove_via_compute
+      add_remove_via_compute(LOW_KEY_COUNT_OPTIONS)
+      add_remove_via_compute(SINGLE_KEY_COUNT_OPTIONS)
+    end
+
+    it 'emove_via_compute_if_absent_present' do
+      add_remove_via_compute_if_absent_present
+      add_remove_via_compute_if_absent_present(LOW_KEY_COUNT_OPTIONS)
+      add_remove_via_compute_if_absent_present(SINGLE_KEY_COUNT_OPTIONS)
+    end
+
+    it 'add_remove_indiscriminate' do
+      add_remove_indiscriminate
+      add_remove_indiscriminate(LOW_KEY_COUNT_OPTIONS)
+      add_remove_indiscriminate(SINGLE_KEY_COUNT_OPTIONS)
+    end
+
+    it 'count_up' do
+      count_up
+      count_up(LOW_KEY_COUNT_OPTIONS)
+      count_up(SINGLE_KEY_COUNT_OPTIONS)
+    end
+
+    it 'count_up_via_compute' do
+      count_up_via_compute
+      count_up_via_compute(LOW_KEY_COUNT_OPTIONS)
+      count_up_via_compute(SINGLE_KEY_COUNT_OPTIONS)
+    end
+
+    it 'count_up_via_merge_pair' do
+      count_up_via_merge_pair
+      count_up_via_merge_pair(LOW_KEY_COUNT_OPTIONS)
+      count_up_via_merge_pair(SINGLE_KEY_COUNT_OPTIONS)
+    end
+
+    it 'count_race' do
+      prelude = 'change = (rand(2) == 1) ? 1 : -1'
+      code = <<-RUBY_EVAL
+        v = cache[key]
+        acc += change if cache.replace_pair(key, v, v + change)
+      RUBY_EVAL
+      do_thread_loop(
+        :count_race, 
+        code, 
+        loop_count: 5, 
+        prelude: prelude, 
+        cache_setup: ZERO_VALUE_CACHE_SETUP
+      ) do |result, cache, options, keys|
+        result_sum = sum(result)
+        expect(sum(keys.map { |key| cache[key] })).to eq result_sum
+        expect(sum(cache.values)).to eq result_sum
+        expect(options[:key_count]).to eq cache.size
+      end
+    end
+
+    it 'get_and_set_new' do
+      code = 'acc += 1 unless cache.get_and_set(key, key)'
+      do_thread_loop(:get_and_set_new, code) do |result, cache, options, keys|
+        expect_standard_accumulator_test_result(result, cache, options, keys)
+      end
+    end
+
+    it 'get_and_set_existing' do
+      code = 'acc += 1 if cache.get_and_set(key, key) == -1'
+      do_thread_loop(
+        :get_and_set_existing, 
+        code, 
+        cache_setup: INITIAL_VALUE_CACHE_SETUP, 
+        initial_value: -1
+      ) do |result, cache, options, keys|
+        expect_standard_accumulator_test_result(result, cache, options, keys)
+      end
+    end
+
+    private
+
+    def compute_if_absent_and_present(opts = {})
+      prelude = 'on_present = rand(2) == 1'
+      code = <<-RUBY_EVAL
+        if on_present
+          cache.compute_if_present(key) { |old_value| acc += 1; old_value + 1 }
+        else
+          cache.compute_if_absent(key)  { acc += 1; 1 }
+        end
+      RUBY_EVAL
+      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|
+          if value = cache[k]
+            stored_sum += value
+            stored_key_count += 1
+          end
+        end
+        expect(stored_sum).to eq sum(result)
+        expect(stored_key_count).to eq cache.size
+      end
+    end
+
+    def add_remove(opts = {})
+      prelude = 'do_add = rand(2) == 1'
+      code = <<-RUBY_EVAL
+        if do_add
+          acc += 1 unless cache.put_if_absent(key, key)
+        else
+          acc -= 1 if cache.delete_pair(key, key)
+        end
+      RUBY_EVAL
+      do_thread_loop(
+        __method__, 
+        code, 
+        {loop_count: 5, prelude: prelude}.merge(opts)
+      ) do |result, cache, options, keys|
+        expect_all_key_mappings_exist(cache, keys, false)
+        expect(cache.size).to eq sum(result)
+      end
+    end
+
+    def add_remove_via_compute(opts = {})
+      prelude = 'do_add = rand(2) == 1'
+      code = <<-RUBY_EVAL
+        cache.compute(key) do |old_value|
+          if do_add
+            acc += 1 unless old_value
+            key
+          else
+            acc -= 1 if old_value
+            nil
+          end
+        end
+      RUBY_EVAL
+      do_thread_loop(
+        __method__, 
+        code, 
+        {loop_count: 5, prelude: prelude}.merge(opts)
+      ) do |result, cache, options, keys|
+        expect_all_key_mappings_exist(cache, keys, false)
+        expect(cache.size).to eq sum(result)
+      end
+    end
+
+    def add_remove_via_compute_if_absent_present(opts = {})
+      prelude = 'do_add = rand(2) == 1'
+      code = <<-RUBY_EVAL
+        if do_add
+          cache.compute_if_absent(key)  { acc += 1; key }
+        else
+          cache.compute_if_present(key) { acc -= 1; nil }
+        end
+      RUBY_EVAL
+      do_thread_loop(
+        __method__, 
+        code, 
+        {loop_count: 5, prelude: prelude}.merge(opts)
+      ) do |result, cache, options, keys|
+        expect_all_key_mappings_exist(cache, keys, false)
+        expect(cache.size).to eq sum(result)
+      end
+    end
+
+    def add_remove_indiscriminate(opts = {})
+      prelude = 'do_add = rand(2) == 1'
+      code = <<-RUBY_EVAL
+        if do_add
+          acc += 1 unless cache.put_if_absent(key, key)
+        else
+          acc -= 1 if cache.delete(key)
+        end
+      RUBY_EVAL
+      do_thread_loop(
+        __method__, 
+        code, 
+        {loop_count: 5, prelude: prelude}.merge(opts)
+      ) do |result, cache, options, keys|
+        expect_all_key_mappings_exist(cache, keys, false)
+        expect(cache.size).to eq sum(result)
+      end
+    end
+
+    def count_up(opts = {})
+      code = <<-RUBY_EVAL
+        v = cache[key]
+        acc += 1 if cache.replace_pair(key, v, v + 1)
+      RUBY_EVAL
+      do_thread_loop(
+        __method__, 
+        code, 
+        {loop_count: 5, cache_setup: ZERO_VALUE_CACHE_SETUP}.merge(opts)
+      ) do |result, cache, options, keys|
+        expect_count_up(result, cache, options, keys)
+      end
+    end
+
+    def count_up_via_compute(opts = {})
+      code = <<-RUBY_EVAL
+        cache.compute(key) do |old_value|
+          acc += 1
+          old_value ? old_value + 1 : 1
+        end
+      RUBY_EVAL
+      do_thread_loop(
+        __method__, 
+        code, {loop_count: 5}.merge(opts)
+      ) do |result, cache, options, keys|
+        expect_count_up(result, cache, options, keys)
+        result.inject(nil) do |previous_value, next_value| # since compute guarantees atomicity all count ups should be equal
+          expect(previous_value).to eq next_value if previous_value
+          next_value
+        end
+      end
+    end
+
+    def count_up_via_merge_pair(opts = {})
+      code = <<-RUBY_EVAL
+        cache.merge_pair(key, 1) { |old_value| old_value + 1 }
+      RUBY_EVAL
+      do_thread_loop(
+        __method__, 
+        code, 
+        {loop_count: 5}.merge(opts)
+      ) do |result, cache, options, keys|
+        all_match      = true
+        expected_value = options[:loop_count] * options[:thread_count]
+        keys.each do |key|
+          value = cache[key]
+          if expected_value != value
+            all_match = false
+            break
+          end
+        end
+        expect(all_match).to be_truthy
+      end
+    end
+
+    def add_remove_to_zero(opts = {})
+      code = <<-RUBY_EVAL
+        acc += 1 unless cache.put_if_absent(key, key)
+        acc -= 1 if cache.delete_pair(key, key)
+      RUBY_EVAL
+      do_thread_loop(
+        __method__, 
+        code, 
+        {loop_count: 5}.merge(opts)
+      ) do |result, cache, options, keys|
+        expect_all_key_mappings_exist(cache, keys, false)
+        expect(cache.size).to eq sum(result)
+      end
+    end
+
+    def add_remove_to_zero_via_merge_pair(opts = {})
+      code = <<-RUBY_EVAL
+        acc += (cache.merge_pair(key, key) {}) ? 1 : -1
+      RUBY_EVAL
+      do_thread_loop(
+        __method__, 
+        code, 
+        {loop_count: 5}.merge(opts)
+      ) do |result, cache, options, keys|
+        expect_all_key_mappings_exist(cache, keys, false)
+        expect(cache.size).to eq sum(result)
+      end
+    end
+
+    def do_thread_loop(name, code, options = {}, &block)
+      options = DEFAULTS.merge(options)
+      meth    = define_loop(name, code, options[:prelude])
+      keys    = to_keys_array(options[:key_count])
+      run_thread_loop(meth, keys, options, &block)
+
+      if options[:key_count] > 1
+        options[:key_count] = (options[:key_count] / 40).to_i
+        keys = to_hash_collision_keys_array(options[:key_count])
+        run_thread_loop(
+          meth, 
+          keys, 
+          options.merge(loop_count: options[:loop_count] * 5), 
+          &block
+        )
+      end
+    end
+
+    def run_thread_loop(meth, keys, options, &block)
+      cache   = options[:cache_setup].call(options, keys)
+      barrier = ThreadSafe::Test::Barrier.new(options[:thread_count])
+      result = (1..options[:thread_count]).map do
+        Thread.new do
+          setup_sync_and_start_loop(
+            meth, 
+            cache, 
+            keys, 
+            barrier, 
+            options[:loop_count]
+          )
+        end
+      end.map(&:value)
+      block.call(result, cache, options, keys) if block_given?
+    end
+
+    def setup_sync_and_start_loop(meth, cache, keys, barrier, loop_count)
+      my_keys = keys.shuffle
+      barrier.await
+      if my_keys.size == 1
+        key = my_keys.first
+        send("#{meth}_single_key", cache, key, loop_count)
+      else
+        send("#{meth}_multiple_keys", cache, my_keys, loop_count)
+      end
+    end
+
+    def define_loop(name, body, prelude)
+      inner_meth_name = :"_#{name}_loop_inner"
+      outer_meth_name = :"_#{name}_loop_outer"
+      # looping is splitted into the "loop methods" to trigger the JIT
+      self.class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+        def #{inner_meth_name}_multiple_keys(cache, keys, i, length, acc)
+          #{prelude}
+          target = i + length
+          while i < target
+            key = keys[i]
+            #{body}
+            i += 1
+          end
+          acc
+        end unless method_defined?(:#{inner_meth_name}_multiple_keys)
+      RUBY_EVAL
+
+      self.class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+        def #{inner_meth_name}_single_key(cache, key, i, length, acc)
+          #{prelude}
+          target = i + length
+          while i < target
+            #{body}
+            i += 1
+          end
+          acc
+        end unless method_defined?(:#{inner_meth_name}_single_key)
+      RUBY_EVAL
+
+      self.class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+        def #{outer_meth_name}_multiple_keys(cache, keys, loop_count)
+          total_length = keys.size
+          acc = 0
+          inc = 100
+          loop_count.times do
+            i = 0
+            pre_loop_inc = total_length % inc
+            acc = #{inner_meth_name}_multiple_keys(cache, keys, i, pre_loop_inc, acc)
+            i += pre_loop_inc
+            while i < total_length
+              acc = #{inner_meth_name}_multiple_keys(cache, keys, i, inc, acc)
+              i += inc
+            end
+          end
+          acc
+        end unless method_defined?(:#{outer_meth_name}_multiple_keys)
+      RUBY_EVAL
+
+      self.class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+        def #{outer_meth_name}_single_key(cache, key, loop_count)
+          acc = 0
+          i   = 0
+          inc = 100
+
+          pre_loop_inc = loop_count % inc
+          acc          = #{inner_meth_name}_single_key(cache, key, i, pre_loop_inc, acc)
+          i += pre_loop_inc
+
+          while i < loop_count
+            acc = #{inner_meth_name}_single_key(cache, key, i, inc, acc)
+            i += inc
+          end
+          acc
+        end unless method_defined?(:#{outer_meth_name}_single_key)
+      RUBY_EVAL
+      outer_meth_name
+    end
+
+    def to_keys_array(key_count)
+      arr = []
+      key_count.times {|i| arr << i}
+      arr
+    end
+
+    def to_hash_collision_keys_array(key_count)
+      to_keys_array(key_count).map { |key| ThreadSafe::Test::HashCollisionKey(key) }
+    end
+
+    def sum(result)
+      result.inject(0) { |acc, i| acc + i }
+    end
+
+    def expect_standard_accumulator_test_result(result, cache, options, keys)
+      expect_all_key_mappings_exist(cache, keys)
+      expect(options[:key_count]).to eq sum(result)
+      expect(options[:key_count]).to eq cache.size
+    end
+
+    def expect_all_key_mappings_exist(cache, keys, all_must_exist = true)
+      keys.each do |key|
+        value = cache[key]
+        if value || all_must_exist
+          expect(key).to eq value unless key == value # don't do a bazzilion assertions unless necessary
+        end
+      end
+    end
+
+    def expect_count_up(result, cache, options, keys)
+      keys.each do |key|
+        value = cache[key]
+        expect(value).to be_truthy unless value
+      end
+      expect(sum(cache.values)).to   eq sum(result)
+      expect(options[:key_count]).to eq cache.size
+    end
+  end unless RUBY_ENGINE == 'rbx' || ENV['TRAVIS']
+end