#2835

Committed 05 Oct 2014 10:16PM UTC coverage: 45.201% (-49.6%) from 94.81%

Build # #2835

Build Type

push

Committed by

Commit Message

Merge pull request #158 from obrok/promise-composition

Promise composition

Run Details

2 of 15 new or added lines in 1 file covered. (13.33%)

1514 existing lines in 84 files now uncovered.

1375 of 3042 relevant lines covered (45.2%)

0.66 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

53.57

/lib/concurrent/atomic_reference/mutex_atomic.rb

require 'thread'
require 'concurrent/atomic_reference/direct_update'
require 'concurrent/atomic_reference/numeric_cas_wrapper'

module Concurrent

  # @!macro atomic_reference
  class MutexAtomic
    include Concurrent::AtomicDirectUpdate
    include Concurrent::AtomicNumericCompareAndSetWrapper

    # @!macro [attach] atomic_reference_method_initialize
    def initialize(value = nil)
      @mutex = Mutex.new
      @value = value
    end

    # @!macro [attach] atomic_reference_method_get
    #
    #   Gets the current value.
    #
    #   @return [Object] the current value
    def get
      @mutex.synchronize { @value }
    end
    alias_method :value, :get

    # @!macro [attach] atomic_reference_method_set
    #
    #   Sets to the given value.
    #
    #   @param [Object] new_value the new value
    #
    #   @return [Object] the new value
    def set(new_value)
      @mutex.synchronize { @value = new_value }
    end
    alias_method :value=, :set

    # @!macro [attach] atomic_reference_method_get_and_set
    #
    #   Atomically sets to the given value and returns the old value.
    #
    #   @param [Object] new_value the new value
    #
    #   @return [Object] the old value
    def get_and_set(new_value)
      @mutex.synchronize do
        old_value = @value
        @value = new_value
        old_value
      end
    end
    alias_method :swap, :get_and_set

    # @!macro [attach] atomic_reference_method_compare_and_set
    #
    #   Atomically sets the value to the given updated value if
    #   the current value == the expected value.
    #
    #   @param [Object] old_value the expected value
    #   @param [Object] new_value the new value
    #
    #   @return [Boolean] `true` if successful. A `false` return indicates
    #   that the actual value was not equal to the expected value.
    def _compare_and_set(old_value, new_value) #:nodoc:
      return false unless @mutex.try_lock
      begin
        return false unless @value.equal? old_value
        @value = new_value
      ensure
        @mutex.unlock
      end
      true
    end
  end
end

1	require 'thread'	1✔
2	require 'concurrent/atomic_reference/direct_update'	1✔
3	require 'concurrent/atomic_reference/numeric_cas_wrapper'	1✔
4
5	module Concurrent	1✔
6
7	# @!macro atomic_reference
8	class MutexAtomic	1✔
9	include Concurrent::AtomicDirectUpdate	1✔
10	include Concurrent::AtomicNumericCompareAndSetWrapper	1✔
11
12	# @!macro [attach] atomic_reference_method_initialize
13	def initialize(value = nil)	1✔
UNCOV 14	@mutex = Mutex.new	×
UNCOV 15	@value = value	×
16	end
17
18	# @!macro [attach] atomic_reference_method_get
19	#
20	# Gets the current value.
21	#
22	# @return [Object] the current value
23	def get	1✔
UNCOV 24	@mutex.synchronize { @value }	×
25	end
26	alias_method :value, :get	1✔
27
28	# @!macro [attach] atomic_reference_method_set
29	#
30	# Sets to the given value.
31	#
32	# @param [Object] new_value the new value
33	#
34	# @return [Object] the new value
35	def set(new_value)	1✔
UNCOV 36	@mutex.synchronize { @value = new_value }	×
37	end
38	alias_method :value=, :set	1✔
39
40	# @!macro [attach] atomic_reference_method_get_and_set
41	#
42	# Atomically sets to the given value and returns the old value.
43	#
44	# @param [Object] new_value the new value
45	#
46	# @return [Object] the old value
47	def get_and_set(new_value)	1✔
UNCOV 48	@mutex.synchronize do	×
UNCOV 49	old_value = @value	×
UNCOV 50	@value = new_value	×
UNCOV 51	old_value	×
52	end
53	end
54	alias_method :swap, :get_and_set	1✔
55
56	# @!macro [attach] atomic_reference_method_compare_and_set
57	#
58	# Atomically sets the value to the given updated value if
59	# the current value == the expected value.
60	#
61	# @param [Object] old_value the expected value
62	# @param [Object] new_value the new value
63	#
64	# @return [Boolean] `true` if successful. A `false` return indicates
65	# that the actual value was not equal to the expected value.
66	def _compare_and_set(old_value, new_value) #:nodoc:	1✔
UNCOV 67	return false unless @mutex.try_lock	×
68	begin
UNCOV 69	return false unless @value.equal? old_value	×
UNCOV 70	@value = new_value	×
71	ensure
UNCOV 72	@mutex.unlock	×
73	end
UNCOV 74	true	×
75	end
76	end
77	end

ruby-concurrency / concurrent-ruby / #2835

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous