Merge pull request #43 from ktdreyer/tests

tests: switch to minitest

Author: thedarkone

test/test_array.rb

@@ -1,20 +1,18 @@
-require 'test/unit'
 require 'thread_safe'
+require File.join(File.dirname(__FILE__), "test_helper")
 
-class TestArray < Test::Unit::TestCase
+class TestArray < Minitest::Test
   def test_concurrency
     ary = ThreadSafe::Array.new
-    assert_nothing_raised do
-      (1..100).map do |i|
-        Thread.new do
-          1000.times do
-            ary << i
-            ary.each {|x| x * 2}
-            ary.shift
-            ary.last
-          end
+    (1..100).map do |i|
+      Thread.new do
+        1000.times do
+          ary << i
+          ary.each {|x| x * 2}
+          ary.shift
+          ary.last
         end
-      end.map(&:join)
-    end
+      end
+    end.map(&:join)
   end
 end

test/test_cache.rb

@@ -1,29 +1,26 @@
-require 'test/unit'
 require 'thread_safe'
 require 'thread'
 require File.join(File.dirname(__FILE__), "test_helper")
 
 Thread.abort_on_exception = true
 
-class TestCache < Test::Unit::TestCase
+class TestCache < Minitest::Test
   def setup
     @cache = ThreadSafe::Cache.new
   end
 
   def test_concurrency
     cache = @cache
-    assert_nothing_raised do
-      (1..100).map do |i|
-        Thread.new do
-          1000.times do |j|
-            key = i*1000+j
-            cache[key] = i
-            cache[key]
-            cache.delete(key)
-          end
+    (1..100).map do |i|
+      Thread.new do
+        1000.times do |j|
+          key = i*1000+j
+          cache[key] = i
+          cache[key]
+          cache.delete(key)
         end
-      end.map(&:join)
-    end
+      end
+    end.map(&:join)
   end
 
   def test_retrieval
@@ -470,7 +467,7 @@ def test_fetch
         assert_equal(1, (@cache.fetch(:a) {flunk}))
       end
 
-      assert_raise(ThreadSafe::Cache::KEY_ERROR) do
+      assert_raises(ThreadSafe::Cache::KEY_ERROR) do
         @cache.fetch(:b)
       end
     end
@@ -554,11 +551,9 @@ def test_each_pair_allows_modification
     @cache[:b] = 1
     @cache[:c] = 1
 
-    assert_nothing_raised do
-      assert_size_change 1 do
-        @cache.each_pair do |k, v|
-          @cache[:z] = 1
-        end
+    assert_size_change 1 do
+      @cache.each_pair do |k, v|
+        @cache[:z] = 1
       end
     end
   end
@@ -704,22 +699,21 @@ def test_dup_clone
   end
 
   def test_is_unfreezable
-    assert_raise(NoMethodError) { @cache.freeze }
+    assert_raises(NoMethodError) { @cache.freeze }
   end
 
   def test_marshal_dump_load
-    assert_nothing_raised do
-      new_cache = Marshal.load(Marshal.dump(@cache))
-      assert_equal 0, new_cache.size
-    end
+    new_cache = Marshal.load(Marshal.dump(@cache))
+    assert_instance_of ThreadSafe::Cache, new_cache
+    assert_equal 0, new_cache.size
     @cache[:a] = 1
     new_cache = Marshal.load(Marshal.dump(@cache))
     assert_equal 1, @cache[:a]
     assert_equal 1, new_cache.size
   end
 
   def test_marshal_dump_doesnt_work_with_default_proc
-    assert_raise(TypeError) do
+    assert_raises(TypeError) do
       Marshal.dump(ThreadSafe::Cache.new {})
     end
   end
@@ -740,15 +734,16 @@ def assert_valid_option(option_name, value)
   end
 
   def assert_valid_options(options)
-    assert_nothing_raised { ThreadSafe::Cache.new(options) }
+    c = ThreadSafe::Cache.new(options)
+    assert_instance_of ThreadSafe::Cache, c
   end
 
   def assert_invalid_option(option_name, value)
     assert_invalid_options(option_name => value)
   end
 
   def assert_invalid_options(options)
-    assert_raise(ArgumentError) { ThreadSafe::Cache.new(options) }
+    assert_raises(ArgumentError) { ThreadSafe::Cache.new(options) }
   end
 
   def assert_size_change(change, cache = @cache)
@@ -782,7 +777,7 @@ def assert_handles_exception(method, key, *args)
     before_had_value = before_had_key ? @cache[key] : nil
 
     assert_no_size_change do
-      assert_raise(TestException) do
+      assert_raises(TestException) do
         @cache.send(method, key, *args) { raise TestException, '' }
       end
       assert_equal before_had_key,   @cache.key?(key)

test/test_cache_loops.rb

@@ -1,11 +1,10 @@
 require 'thread'
-require 'test/unit'
 require 'thread_safe'
 require File.join(File.dirname(__FILE__), "test_helper")
 
 Thread.abort_on_exception = true
 
-class TestCacheTorture < Test::Unit::TestCase # this is not run unless RUBY_VERSION =~ /1\.8/ || ENV['TRAVIS'] (see the end of the file)
+class TestCacheTorture < Minitest::Test # this is not run unless RUBY_VERSION =~ /1\.8/ || ENV['TRAVIS'] (see the end of the file)
   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
@@ -310,15 +309,13 @@ def add_remove_to_zero_via_merge_pair(opts = {})
   def do_thread_loop(name, code, options = {}, &block)
     options = DEFAULTS.merge(options)
     meth    = define_loop name, code, options[:prelude]
-    assert_nothing_raised do
-      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
+    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
 

test/test_hash.rb

@@ -1,19 +1,17 @@
-require 'test/unit'
 require 'thread_safe'
+require File.join(File.dirname(__FILE__), "test_helper")
 
-class TestHash < Test::Unit::TestCase
+class TestHash < Minitest::Test
   def test_concurrency
     hsh = ThreadSafe::Hash.new
-    assert_nothing_raised do
-      (1..100).map do |i|
-        Thread.new do
-          1000.times do |j|
-            hsh[i*1000+j] = i
-            hsh[i*1000+j]
-            hsh.delete(i*1000+j)
-          end
+    (1..100).map do |i|
+      Thread.new do
+        1000.times do |j|
+          hsh[i*1000+j] = i
+          hsh[i*1000+j]
+          hsh.delete(i*1000+j)
         end
-      end.map(&:join)
-    end
+      end
+    end.map(&:join)
   end
 end

test/test_helper.rb

@@ -1,4 +1,12 @@
 require 'thread'
+require 'minitest/autorun'
+
+if Minitest.const_defined?('Test')
+  # We're on Minitest 5+. Nothing to do here.
+else
+  # Minitest 4 doesn't have Minitest::Test yet.
+  Minitest::Test = MiniTest::Unit::TestCase
+end
 
 if defined?(JRUBY_VERSION) && ENV['TEST_NO_UNSAFE']
   # to be used like this: rake test TEST_NO_UNSAFE=true
@@ -10,7 +18,7 @@
   manager.deny java.lang.RuntimePermission.new("accessClassInPackage.sun.misc")
   java.lang.System.setSecurityManager manager
 
-  class TestNoUnsafe < Test::Unit::TestCase
+  class TestNoUnsafe < Minitest::Test
     def test_security_manager_is_used
       begin
         java_import 'sun.misc.Unsafe'

test/test_synchronized_delegator.rb

@@ -1,7 +1,7 @@
-require 'test/unit'
 require 'thread_safe/synchronized_delegator.rb'
+require File.join(File.dirname(__FILE__), "test_helper")
 
-class TestSynchronizedDelegator < Test::Unit::TestCase
+class TestSynchronizedDelegator < Minitest::Test
 
   def test_wraps_array
     sync_array = SynchronizedDelegator.new(array = [])

thread_safe.gemspec

@@ -21,4 +21,5 @@ Gem::Specification.new do |gem|
 
   gem.add_development_dependency 'atomic', ['>= 1.1.7', '< 2']
   gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'minitest'
 end