added pending test and begun implementation

Author: mighe

lib/concurrent/atomic/cyclic_barrier.rb

@@ -9,34 +9,51 @@ class CyclicBarrier
     #
     # @raise [ArgumentError] if `parties` is not an integer or is less than zero
     def initialize(parties)
+      raise ArgumentError.new('count must be in integer greater than or equal zero') if !parties.is_a?(Fixnum) || parties < 1
+      @parties = parties
+      @mutex = Mutex.new
+      @condition = Condition.new
+      @number_waiting = 0
     end
 
     # @return [Fixnum] the number of threads needed to pass the barrier
     def parties
+      @parties
     end
 
     # @return [Fixnum] the number of threads currently waiting on the barrier
     def number_waiting
+      @number_waiting
     end
 
     # Blocks on the barrier until the number of waiting threads is equal to `parties` or until `timeout` is reached or `reset` is called
     # @param [Fixnum] timeout the number of seconds to wait for the counter or `nil` to block indefinitely
     # @return [Boolean] `true` if the `count` reaches zero else false on `timeout` or on `reset`
     def wait(timeout = nil)
+      @mutex.synchronize do
+        @number_waiting += 1
+        if @number_waiting == @parties
+          @condition.broadcast
+          @number_waiting = 0
+        else
+          @condition.wait(@mutex)
+        end
+      end
     end
 
     # resets the barrier to its initial state
     # If there is at least one waiting thread, it will be woken up, the `wait` method will return false and the barrier will be broken
+    # If the barrier is broken, this method restores it to the original state
     #
     # @return [nil]
     def reset
     end
 
     # A barrier can be broken when:
-    # - a thread called the `reset` method while at least one thread was waiting
+    # - a thread called the `reset` method while at least one other thread was waiting
     # - at least one thread timed out on `wait` method
     #
-    # A broken barrier cannot be restored and it should not be reused: it's safer to create a new one
+    # A broken barrier can be restored using `reset` it's safer to create a new one
     # @return [Boolean] true if the barrier is broken otherwise false
     def broken?
     end

spec/concurrent/atomic/cyclic_barrier_spec.rb

@@ -4,6 +4,95 @@ module Concurrent
 
   describe CyclicBarrier do
 
+    let(:parties) { 3 }
+    let!(:barrier) { described_class.new(3) }
+
+    context '#initialize' do
+
+      it 'raises an exception if the initial count is less than 1' do
+        expect {
+          described_class.new(0)
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'raises an exception if the initial count is not an integer' do
+        expect {
+          described_class.new('foo')
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe '#parties' do
+
+      it 'should be the value passed to the constructor' do
+        barrier.parties.should eq 3
+      end
+
+    end
+
+    describe '#number_waiting' do
+      context 'without any waiting thread' do
+        it 'should be equal to zero' do
+          barrier.number_waiting.should eq 0
+        end
+      end
+
+      context 'with waiting threads' do
+        it 'should be equal to the waiting threads count' do
+          Thread.new { barrier.wait }
+          Thread.new { barrier.wait }
+
+          sleep(0.1)
+
+          barrier.number_waiting.should eq 2
+        end
+      end
+    end
+
+    describe '#broken?' do
+      it 'should not be broken when created'
+      it 'should not be broken when reset is called without waiting thread'
+      it 'should be broken when at least one thread timed out'
+      it 'should be restored when reset is called'
+    end
+
+    describe 'reset' do
+      it 'should release all waiting threads'
+      it 'should not execute the block'
+    end
+
+    describe '#wait' do
+      context 'without timeout' do
+        it 'should block the thread' do
+          t = Thread.new { barrier.wait }
+          sleep(0.1)
+
+          t.status.should eq 'sleep'
+        end
+
+        it 'should release all threads when their number matches the desired one' do
+          latch = CountDownLatch.new(parties)
+
+          parties.times { Thread.new { barrier.wait; latch.count_down } }
+          latch.wait(0.2).should be_true
+          barrier.number_waiting.should eq 0
+        end
+
+        it 'executes the block'
+      end
+
+      context 'with timeout' do
+        it 'should block the thread'
+        it 'should release all threads when their number matches the desired one'
+        it 'can return early and break the barrier'
+        it 'does not execute the block on timeout'
+      end
+    end
+
+    context 'spurious wakeups' do
+      it 'should resist'
+    end
+
   end