GitBucket
Newer
Thread.abort_on_exception = true
module ThreadSafe
describe Cache do
before(:each) do
@cache = described_class.new
end
it 'concurrency' do
(1..THREADS).map do |i|
Thread.new do
1000.times do |j|
key = i * 1000 + j
@cache[key] = i
@cache[key]
@cache.delete(key)
end
end
end.map(&:join)
end
it 'retrieval' do
expect_size_change(1) do
expect(nil).to eq @cache[:a]
expect(nil).to eq @cache.get(:a)
@cache[:a] = 1
expect(1).to eq @cache[:a]
expect(1).to eq @cache.get(:a)
end
end
it '#put_if_absent' do
with_or_without_default_proc do
expect_size_change(1) do
expect(nil).to eq @cache.put_if_absent(:a, 1)
expect(1).to eq @cache.put_if_absent(:a, 1)
expect(1).to eq @cache.put_if_absent(:a, 2)
expect(1).to eq @cache[:a]
end
end
end
describe '#compute_if_absent' do
it 'common' do
with_or_without_default_proc do
expect_size_change(3) do
expect(1).to eq @cache.compute_if_absent(:a) { 1 }
expect(1).to eq @cache.compute_if_absent(:a) { 2 }
expect(1).to eq @cache[:a]
@cache[:b] = nil
expect(nil).to eq @cache.compute_if_absent(:b) { 1 }
expect(nil).to eq @cache.compute_if_absent(:c) {}
expect(nil).to eq @cache[:c]
expect(true).to eq @cache.key?(:c)
end
end
end
it 'with return' do
with_or_without_default_proc do
expect_handles_return_lambda(:compute_if_absent, :a)
end
end
it 'exception' do
with_or_without_default_proc do
expect_handles_exception(:compute_if_absent, :a)
end
end
it 'atomicity' do
late_compute_threads_count = 10
late_put_if_absent_threads_count = 10
getter_threads_count = 5
compute_started = ThreadSafe::Test::Latch.new(1)
compute_proceed = ThreadSafe::Test::Latch.new(
late_compute_threads_count +
late_put_if_absent_threads_count +
getter_threads_count
)
block_until_compute_started = lambda do |name|
# what does it mean?
if (v = @cache[:a]) != nil
expect(nil).to v
end
compute_proceed.release
compute_started.await
end
expect_size_change 1 do
late_compute_threads = Array.new(late_compute_threads_count) do
Thread.new do
block_until_compute_started.call('compute_if_absent')
expect(1).to eq @cache.compute_if_absent(:a) { fail }
end
end
late_put_if_absent_threads = Array.new(late_put_if_absent_threads_count) do
Thread.new do
block_until_compute_started.call('put_if_absent')
expect(1).to eq @cache.put_if_absent(:a, 2)
end
end
getter_threads = Array.new(getter_threads_count) do
Thread.new do
block_until_compute_started.call('getter')
Thread.pass while @cache[:a].nil?
expect(1).to eq @cache[:a]
end
end
Thread.new do
@cache.compute_if_absent(:a) do
compute_started.release
compute_proceed.await
sleep(0.2)
1
end
end.join
(late_compute_threads +
late_put_if_absent_threads +
getter_threads).each(&:join)
end
end
end
describe '#compute_if_present' do
it 'common' do
with_or_without_default_proc do
expect_no_size_change do
expect(nil).to eq @cache.compute_if_present(:a) {}
expect(nil).to eq @cache.compute_if_present(:a) { 1 }
expect(nil).to eq @cache.compute_if_present(:a) { fail }
expect(false).to eq @cache.key?(:a)
end
@cache[:a] = 1
expect_no_size_change do
expect(1).to eq @cache.compute_if_present(:a) { 1 }
expect(1).to eq @cache[:a]
expect(2).to eq @cache.compute_if_present(:a) { 2 }
expect(2).to eq @cache[:a]
expect(false).to eq @cache.compute_if_present(:a) { false }
expect(false).to eq @cache[:a]
@cache[:a] = 1
yielded = false
@cache.compute_if_present(:a) do |old_value|
yielded = true
expect(1).to eq old_value
2
end
expect(true).to eq yielded
end
expect_size_change(-1) do
expect(nil).to eq @cache.compute_if_present(:a) {}
expect(false).to eq @cache.key?(:a)
expect(nil).to eq @cache.compute_if_present(:a) { 1 }
expect(false).to eq @cache.key?(:a)
end
end
end
it 'with return' do
with_or_without_default_proc do
@cache[:a] = 1
expect_handles_return_lambda(:compute_if_present, :a)
end
end
it 'exception' do
with_or_without_default_proc do
@cache[:a] = 1
expect_handles_exception(:compute_if_present, :a)
end
end
end
describe '#compute' do
it 'common' do
with_or_without_default_proc do
expect_no_size_change do
expect_compute(:a, nil, nil) {}
end
expect_size_change(1) do
expect_compute(:a, nil, 1) { 1 }
expect_compute(:a, 1, 2) { 2 }
expect_compute(:a, 2, false) { false }
expect(false).to eq @cache[:a]
end
expect_size_change(-1) do
expect_compute(:a, false, nil) {}
end
end
end
it 'with return' do
with_or_without_default_proc do
expect_handles_return_lambda(:compute, :a)
@cache[:a] = 1
expect_handles_return_lambda(:compute, :a)
end
end
it 'exception' do
with_or_without_default_proc do
expect_handles_exception(:compute, :a)
@cache[:a] = 2
expect_handles_exception(:compute, :a)
end
end
end
describe '#merge_pair' do
it 'common' do
with_or_without_default_proc do
expect_size_change(1) do
expect(nil).to eq @cache.merge_pair(:a, nil) { fail }
expect(true).to eq @cache.key?(:a)
expect(nil).to eq @cache[:a]
end
expect_no_size_change do
expect_merge_pair(:a, nil, nil, false) { false }
expect_merge_pair(:a, nil, false, 1) { 1 }
expect_merge_pair(:a, nil, 1, 2) { 2 }
end
expect_size_change(-1) do
expect_merge_pair(:a, nil, 2, nil) {}
expect(false).to eq @cache.key?(:a)
end
end
end
it 'with return' do
with_or_without_default_proc do
@cache[:a] = 1
expect_handles_return_lambda(:merge_pair, :a, 2)
end
end
it 'exception' do
with_or_without_default_proc do
@cache[:a] = 1
expect_handles_exception(:merge_pair, :a, 2)
end
end
end
it 'updates dont block reads' do
getters_count = 20
key_klass = ThreadSafe::Test::HashCollisionKey
keys = [key_klass.new(1, 100),
key_klass.new(2, 100),
key_klass.new(3, 100)] # hash colliding keys
inserted_keys = []
keys.each do |key, i|
compute_started = ThreadSafe::Test::Latch.new(1)
compute_finished = ThreadSafe::Test::Latch.new(1)
getters_started = ThreadSafe::Test::Latch.new(getters_count)
getters_finished = ThreadSafe::Test::Latch.new(getters_count)
computer_thread = Thread.new do
getters_started.await
@cache.compute_if_absent(key) do
compute_started.release
getters_finished.await
1
end
compute_finished.release
end
getter_threads = (1..getters_count).map do
Thread.new do
getters_started.release
inserted_keys.each do |inserted_key|
expect(true).to eq @cache.key?(inserted_key)
expect(1).to eq @cache[inserted_key]
end
expect(false).to eq @cache.key?(key)
compute_started.await
inserted_keys.each do |inserted_key|
expect(true).to eq @cache.key?(inserted_key)
expect(1).to eq @cache[inserted_key]
end
expect(false).to eq @cache.key?(key)
expect(nil).to eq @cache[key]
getters_finished.release
compute_finished.await
expect(true).to eq @cache.key?(key)
expect(1).to eq @cache[key]
end
end
(getter_threads << computer_thread).map do |t|
expect(t.join(2)).to be_truthy
end # asserting no deadlocks
inserted_keys << key
end
end
specify 'collision resistance' do
expect_collision_resistance(
(0..1000).map { |i| ThreadSafe::Test::HashCollisionKey(i, 1) }
)
end
specify 'collision resistance with arrays' do
special_array_class = Class.new(Array) do
def key # assert_collision_resistance expects to be able to call .key to get the "real" key
first.key
end
end
# Test collision resistance with a keys that say they responds_to <=>, but then raise exceptions
# when actually called (ie: an Array filled with non-comparable keys).
# See https://github.com/headius/thread_safe/issues/19 for more info.
expect_collision_resistance(
(0..100).map do |i|
special_array_class.new(
[ThreadSafe::Test::HashCollisionKeyNonComparable.new(i, 1)]
)
end
)
end
it '#replace_pair' do
with_or_without_default_proc do
expect_no_size_change do
expect(false).to eq @cache.replace_pair(:a, 1, 2)
expect(false).to eq @cache.replace_pair(:a, nil, nil)
expect(false).to eq @cache.key?(:a)
end
end
@cache[:a] = 1
expect_no_size_change do
expect(true).to eq @cache.replace_pair(:a, 1, 2)
expect(false).to eq @cache.replace_pair(:a, 1, 2)
expect(2).to eq @cache[:a]
expect(true).to eq @cache.replace_pair(:a, 2, 2)
expect(2).to eq @cache[:a]
expect(true).to eq @cache.replace_pair(:a, 2, nil)
expect(false).to eq @cache.replace_pair(:a, 2, nil)
expect(nil).to eq @cache[:a]
expect(true).to eq @cache.key?(:a)
expect(true).to eq @cache.replace_pair(:a, nil, nil)
expect(true).to eq @cache.key?(:a)
expect(true).to eq @cache.replace_pair(:a, nil, 1)
expect(1).to eq @cache[:a]
end
end
it '#replace_if_exists' do
with_or_without_default_proc do
expect_no_size_change do
expect(nil).to eq @cache.replace_if_exists(:a, 1)
expect(false).to eq @cache.key?(:a)
end
@cache[:a] = 1
expect_no_size_change do
expect(1).to eq @cache.replace_if_exists(:a, 2)
expect(2).to eq @cache[:a]
expect(2).to eq @cache.replace_if_exists(:a, nil)
expect(nil).to eq @cache[:a]
expect(true).to eq @cache.key?(:a)
expect(nil).to eq @cache.replace_if_exists(:a, 1)
expect(1).to eq @cache[:a]
end
end
end
it '#get_and_set' do
with_or_without_default_proc do
expect(nil).to eq @cache.get_and_set(:a, 1)
expect(true).to eq @cache.key?(:a)
expect(1).to eq @cache[:a]
expect(1).to eq @cache.get_and_set(:a, 2)
expect(2).to eq @cache.get_and_set(:a, nil)
expect(nil).to eq @cache[:a]
expect(true).to eq @cache.key?(:a)
expect(nil).to eq @cache.get_and_set(:a, 1)
expect(1).to eq @cache[:a]
end
end
it '#key' do
with_or_without_default_proc do
expect(nil).to eq @cache.key(1)
@cache[:a] = 1
expect(:a).to eq @cache.key(1)
expect(nil).to eq @cache.key(0)
end
end
it '#key?' do
with_or_without_default_proc do
expect(false).to eq @cache.key?(:a)
@cache[:a] = 1
expect(true).to eq @cache.key?(:a)
end
end
it '#value?' do
with_or_without_default_proc do
expect(false).to eq @cache.value?(1)
@cache[:a] = 1
expect(true).to eq @cache.value?(1)
end
end
it '#delete' do
with_or_without_default_proc do |default_proc_set|
expect_no_size_change do
expect(nil).to eq @cache.delete(:a)
end
@cache[:a] = 1
expect_size_change -1 do
expect(1).to eq @cache.delete(:a)
end
expect_no_size_change do
expect(nil).to eq @cache[:a] unless default_proc_set
expect(false).to eq @cache.key?(:a)
expect(nil).to eq @cache.delete(:a)
end
end
end
it '#delete_pair' do
with_or_without_default_proc do
expect_no_size_change do
expect(false).to eq @cache.delete_pair(:a, 2)
expect(false).to eq @cache.delete_pair(:a, nil)
end
@cache[:a] = 1
expect_no_size_change do
expect(false).to eq @cache.delete_pair(:a, 2)
end
expect_size_change(-1) do
expect(1).to eq @cache[:a]
expect(true).to eq @cache.delete_pair(:a, 1)
expect(false).to eq @cache.delete_pair(:a, 1)
expect(false).to eq @cache.key?(:a)
end
end
end
specify 'default proc' do
@cache = cache_with_default_proc(1)
expect_no_size_change do
expect(false).to eq @cache.key?(:a)
end
expect_size_change(1) do
expect(1).to eq @cache[:a]
expect(true).to eq @cache.key?(:a)
end
end
specify 'falsy default proc' do
@cache = cache_with_default_proc(nil)
expect_no_size_change do
expect(false).to eq @cache.key?(:a)
end
expect_size_change(1) do
expect(nil).to eq @cache[:a]
expect(true).to eq @cache.key?(:a)
end
end
describe '#fetch' do
it 'common' do
with_or_without_default_proc do |default_proc_set|
expect_no_size_change do
expect(1).to eq @cache.fetch(:a, 1)
expect(1).to eq @cache.fetch(:a) { 1 }
expect(false).to eq @cache.key?(:a)
expect(nil).to eq @cache[:a] unless default_proc_set
end
@cache[:a] = 1
expect_no_size_change do
expect(1).to eq @cache.fetch(:a) { fail }
end
expect { @cache.fetch(:b) }.to raise_error(KeyError)
expect_no_size_change do
expect(1).to eq @cache.fetch(:b, :c) {1} # assert block supersedes default value argument
expect(false).to eq @cache.key?(:b)
end
end
end
it 'falsy' do
with_or_without_default_proc do
expect(false).to eq @cache.key?(:a)
expect_no_size_change do
expect(nil).to eq @cache.fetch(:a, nil)
expect(false).to eq @cache.fetch(:a, false)
expect(nil).to eq @cache.fetch(:a) {}
expect(false).to eq @cache.fetch(:a) { false }
end
@cache[:a] = nil
expect_no_size_change do
expect(true).to eq @cache.key?(:a)
expect(nil).to eq @cache.fetch(:a) { fail }
end
end
end
it 'with return' do
with_or_without_default_proc do
r = fetch_with_return
# r = lambda do
# @cache.fetch(:a) { return 10 }
# end.call
expect_no_size_change do
expect(10).to eq r
expect(false).to eq @cache.key?(:a)
end
end
end
end
describe '#fetch_or_store' do
it 'common' do
with_or_without_default_proc do |default_proc_set|
expect_size_change(1) do
expect(1).to eq @cache.fetch_or_store(:a, 1)
expect(1).to eq @cache[:a]
end
@cache.delete(:a)
expect_size_change 1 do
expect(1).to eq @cache.fetch_or_store(:a) { 1 }
expect(1).to eq @cache[:a]
end
expect_no_size_change do
expect(1).to eq @cache.fetch_or_store(:a) { fail }
end
expect { @cache.fetch_or_store(:b) }.
to raise_error(KeyError)
expect_size_change(1) do
expect(1).to eq @cache.fetch_or_store(:b, :c) { 1 } # assert block supersedes default value argument
expect(1).to eq @cache[:b]
end
end
end
it 'falsy' do
with_or_without_default_proc do
expect(false).to eq @cache.key?(:a)
expect_size_change(1) do
expect(nil).to eq @cache.fetch_or_store(:a, nil)
expect(nil).to eq @cache[:a]
expect(true).to eq @cache.key?(:a)
end
@cache.delete(:a)
expect_size_change(1) do
expect(false).to eq @cache.fetch_or_store(:a, false)
expect(false).to eq @cache[:a]
expect(true).to eq @cache.key?(:a)
end
@cache.delete(:a)
expect_size_change(1) do
expect(nil).to eq @cache.fetch_or_store(:a) {}
expect(nil).to eq @cache[:a]
expect(true).to eq @cache.key?(:a)
end
@cache.delete(:a)
expect_size_change(1) do
expect(false).to eq @cache.fetch_or_store(:a) { false }
expect(false).to eq @cache[:a]
expect(true).to eq @cache.key?(:a)
end
@cache[:a] = nil
expect_no_size_change do
expect(nil).to eq @cache.fetch_or_store(:a) { fail }
end
end
end
it 'with return' do
with_or_without_default_proc do
r = fetch_or_store_with_return
expect_no_size_change do
expect(10).to eq r
expect(false).to eq @cache.key?(:a)
end
end
end
end
it '#clear' do
@cache[:a] = 1
expect_size_change(-1) do
expect(@cache).to eq @cache.clear
expect(false).to eq @cache.key?(:a)
expect(nil).to eq @cache[:a]
end
end
describe '#each_pair' do
it 'common' do
@cache.each_pair { |k, v| fail }
expect(@cache).to eq @cache.each_pair {}
@cache[:a] = 1
h = {}
@cache.each_pair { |k, v| h[k] = v }
expect({:a => 1}).to eq h
@cache[:b] = 2
h = {}
@cache.each_pair { |k, v| h[k] = v }
expect({:a => 1, :b => 2}).to eq h
end
it 'pair iterator' do
@cache[:a] = 1
@cache[:b] = 2
i = 0
r = @cache.each_pair do |k, v|
if i == 0
i += 1
next
fail
elsif i == 1
break :breaked
end
end
expect(:breaked).to eq r
end
it 'allows modification' do
@cache[:a] = 1
@cache[:b] = 1
@cache[:c] = 1
expect_size_change(1) do
@cache.each_pair do |k, v|
@cache[:z] = 1
end
end
end
end
it '#keys' do
expect([]).to eq @cache.keys
@cache[1] = 1
expect([1]).to eq @cache.keys
@cache[2] = 2
expect([1, 2]).to eq @cache.keys.sort
end
it '#values' do
expect([]).to eq @cache.values
@cache[1] = 1
expect([1]).to eq @cache.values
@cache[2] = 2
expect([1, 2]).to eq @cache.values.sort
end
it '#each_key' do
expect(@cache).to eq @cache.each_key { fail }
@cache[1] = 1
arr = []
@cache.each_key { |k| arr << k }
expect([1]).to eq arr
@cache[2] = 2
arr = []
@cache.each_key { |k| arr << k }
expect([1, 2]).to eq arr.sort
end
it '#each_value' do
expect(@cache).to eq @cache.each_value { fail }
@cache[1] = 1
arr = []
@cache.each_value { |k| arr << k }
expect([1]).to eq arr
@cache[2] = 2
arr = []
@cache.each_value { |k| arr << k }
expect([1, 2]).to eq arr.sort
end
it '#empty' do
expect(true).to eq @cache.empty?
@cache[:a] = 1
expect(false).to eq @cache.empty?
end
it 'options validation' do
expect_valid_options(nil)
expect_valid_options({})
expect_valid_options(foo: :bar)
end
it 'initial capacity options validation' do
expect_valid_option(:initial_capacity, nil)
expect_valid_option(:initial_capacity, 1)
expect_invalid_option(:initial_capacity, '')
expect_invalid_option(:initial_capacity, 1.0)
expect_invalid_option(:initial_capacity, -1)
end
it 'load factor options validation' do
expect_valid_option(:load_factor, nil)
expect_valid_option(:load_factor, 0.01)
expect_valid_option(:load_factor, 0.75)
expect_valid_option(:load_factor, 1)
expect_invalid_option(:load_factor, '')
expect_invalid_option(:load_factor, 0)
expect_invalid_option(:load_factor, 1.1)
expect_invalid_option(:load_factor, 2)
expect_invalid_option(:load_factor, -1)
end
it '#size' do
expect(0).to eq @cache.size
@cache[:a] = 1
expect(1).to eq @cache.size
@cache[:b] = 1
expect(2).to eq @cache.size
@cache.delete(:a)
expect(1).to eq @cache.size
@cache.delete(:b)
expect(0).to eq @cache.size
end
it '#get_or_default' do
with_or_without_default_proc do
expect(1).to eq @cache.get_or_default(:a, 1)
expect(nil).to eq @cache.get_or_default(:a, nil)
expect(false).to eq @cache.get_or_default(:a, false)
expect(false).to eq @cache.key?(:a)
@cache[:a] = 1
expect(1).to eq @cache.get_or_default(:a, 2)
end
end
it '#dup,#clone' do
[:dup, :clone].each do |meth|
cache = cache_with_default_proc(:default_value)
cache[:a] = 1
dupped = cache.send(meth)
expect(1).to eq dupped[:a]
expect(1).to eq dupped.size
expect_size_change(1, cache) do
expect_no_size_change(dupped) do
cache[:b] = 1
end
end
expect(false).to eq dupped.key?(:b)
expect_no_size_change(cache) do
expect_size_change(-1, dupped) do
dupped.delete(:a)
end
end
expect(false).to eq dupped.key?(:a)
expect(true).to eq cache.key?(:a)
# test default proc
expect_size_change(1, cache) do
expect_no_size_change dupped do
expect(:default_value).to eq cache[:c]
expect(false).to eq dupped.key?(:c)
end
end
expect_no_size_change cache do
expect_size_change 1, dupped do
expect(:default_value).to eq dupped[:d]
expect(false).to eq cache.key?(:d)
end
end
end
end
it 'is unfreezable' do
expect { @cache.freeze }.to raise_error(NoMethodError)
end
it 'marshal dump load' do
new_cache = Marshal.load(Marshal.dump(@cache))
expect(new_cache).to be_an_instance_of ThreadSafe::Cache
expect(0).to eq new_cache.size
@cache[:a] = 1
new_cache = Marshal.load(Marshal.dump(@cache))
expect(1).to eq @cache[:a]
expect(1).to eq new_cache.size
end
it 'marshal dump doesnt work with default proc' do
expect { Marshal.dump(ThreadSafe::Cache.new {}) }.to raise_error(TypeError)
end
private
def with_or_without_default_proc(&block)
block.call(false)
@cache = ThreadSafe::Cache.new { |h, k| h[k] = :default_value }
block.call(true)
end
def cache_with_default_proc(default_value = 1)
ThreadSafe::Cache.new { |cache, k| cache[k] = default_value }
end
def expect_size_change(change, cache = @cache, &block)
start = cache.size
block.call
expect(change).to eq cache.size - start
end
def expect_valid_option(option_name, value)
expect_valid_options(option_name => value)
end
def expect_valid_options(options)
c = ThreadSafe::Cache.new(options)
expect(c).to be_an_instance_of ThreadSafe::Cache
end
def expect_invalid_option(option_name, value)
expect_invalid_options(option_name => value)
end
def expect_invalid_options(options)
expect { ThreadSafe::Cache.new(options) }.to raise_error(ArgumentError)
end
def expect_no_size_change(cache = @cache, &block)
expect_size_change(0, cache, &block)
end
def expect_handles_return_lambda(method, key, *args)
before_had_key = @cache.key?(key)
before_had_value = before_had_key ? @cache[key] : nil
returning_lambda = lambda do
@cache.send(method, key, *args) { return :direct_return }
end
expect_no_size_change do
expect(:direct_return).to eq returning_lambda.call
expect(before_had_key).to eq @cache.key?(key)
expect(before_had_value).to eq @cache[key] if before_had_value
end
end
class TestException < Exception; end
def expect_handles_exception(method, key, *args)
before_had_key = @cache.key?(key)
before_had_value = before_had_key ? @cache[key] : nil
expect_no_size_change do
expect { @cache.send(method, key, *args) { raise TestException, '' } }.
to raise_error(TestException)
expect(before_had_key).to eq @cache.key?(key)
expect(before_had_value).to eq @cache[key] if before_had_value
end
end
def expect_compute(key, expected_old_value, expected_result, &block)
result = @cache.compute(:a) do |old_value|
expect(expected_old_value).to eq old_value
block.call
end
expect(expected_result).to eq result
end
def expect_merge_pair(key, value, expected_old_value, expected_result, &block)
result = @cache.merge_pair(key, value) do |old_value|
expect(expected_old_value).to eq old_value
block.call
end
expect(expected_result).to eq result
end
def expect_collision_resistance(keys)
keys.each { |k| @cache[k] = k.key }
10.times do |i|
size = keys.size
while i < size
k = keys[i]
expect(k.key == @cache.delete(k) &&
!@cache.key?(k) &&
(@cache[k] = k.key; @cache[k] == k.key)).to be_truthy
i += 10
end
end
expect(keys.all? { |k| @cache[k] == k.key }).to be_truthy
end
# Took out for compatibility with Rubinius, see https://github.com/rubinius/rubinius/issues/1312
def fetch_with_return
lambda do
@cache.fetch(:a) { return 10 }
end.call
end
# Took out for compatibility with Rubinius, see https://github.com/rubinius/rubinius/issues/1312
def fetch_or_store_with_return
lambda do
@cache.fetch_or_store(:a) { return 10 }
end.call
end
end
end