concurrent-ruby 0.6.0.pre.1 → 0.6.0.pre.2

data/spec/concurrent/{event_spec.rb → atomic/event_spec.rb}

@@ -21,7 +21,6 @@ module Concurrent
       end
 
       it 'returns false if the event is unset' do
-        #subject.reset
         subject.should_not be_set
       end
     end
@@ -29,7 +28,6 @@ module Concurrent
     context '#set' do
 
       it 'triggers the event' do
-        #subject.reset
         @expected = false
         Thread.new{ subject.wait; @expected = true }
         sleep(0.1)
@@ -44,13 +42,30 @@ module Concurrent
       end
     end
 
+    context '#try?' do
+
+      it 'triggers the event if not already set' do
+        subject.try?
+        subject.should be_set
+      end
+
+      it 'returns true if not previously set' do
+        subject.try?.should be_true
+      end
+
+      it 'returns false if previously set' do
+        subject.set
+        subject.try?.should be_false
+      end
+    end
+
     context '#reset' do
 
       it 'does not change the state of an unset event' do
         subject.reset
         subject.should_not be_set
       end
- 
+
       it 'does not trigger an unset event' do
         @expected = false
         Thread.new{ subject.wait; @expected = true }

data/spec/concurrent/{observer_set_shared.rb → atomic/observer_set_shared.rb}

@@ -8,15 +8,16 @@ shared_examples "an observer set" do
 
   describe '#add_observer' do
 
-    context 'with argument' do
-      it 'should return the passed function' do
-        observer_set.add_observer(observer, :a_method).should eq(:a_method)
+    context 'with arguments' do
+      it 'should return the observer' do
+        observer_set.add_observer(observer, :a_method).should == observer
       end
     end
 
-    context 'without arguments' do
-      it 'should return the default function' do
-        observer_set.add_observer(observer).should eq(:update)
+    context 'with a block' do
+      it 'should return the observer based on a block' do
+        observer = observer_set.add_observer { :block }
+        observer.call.should == :block
       end
     end
   end
@@ -61,6 +62,14 @@ shared_examples "an observer set" do
         observer_set.notify_observers('a string arg')
       end
 
+      it 'should notify an observer from a block' do
+        notification = double
+        expect(notification).to receive(:catch)
+
+        observer_set.add_observer {|arg| arg.catch }
+        observer_set.notify_observers notification
+      end
+
       it 'can be called many times' do
         expect(observer).to receive(:update).with(:an_arg).twice
         expect(observer).to receive(:update).with(no_args).once

data/spec/concurrent/channel/buffered_channel_spec.rb

@@ -6,7 +6,7 @@ module Concurrent
 
     let(:size) { 2 }
     let!(:channel) { BufferedChannel.new(size) }
-    let(:probe) { Probe.new }
+    let(:probe) { Channel::Probe.new }
 
     context 'without timeout' do
 

data/spec/concurrent/channel/channel_spec.rb

@@ -12,22 +12,24 @@ module Concurrent
 
           Thread.new { channels[1].push 77 }
 
-          value = Channel.select(*channels)
+          value, channel = Channel.select(*channels)
 
           value.should eq 77
+          channel.should be channels[1]
         end
 
         it 'cleans up' do
           channels = [ UnbufferedChannel.new, UnbufferedChannel.new]
-          channels.each { |ch| ch.stub(:remove_probe).with( an_instance_of(Probe) )}
+          channels.each { |ch| ch.stub(:remove_probe).with( an_instance_of(Channel::Probe) )}
 
           Thread.new { channels[1].push 77 }
 
-          value = Channel.select(*channels)
+          value, channel = Channel.select(*channels)
 
           value.should eq 77
+          channel.should be channels[1]
 
-          channels.each { |ch| expect(ch).to have_received(:remove_probe).with( an_instance_of(Probe) ) }
+          channels.each { |ch| expect(ch).to have_received(:remove_probe).with( an_instance_of(Channel::Probe) ) }
         end
       end
 

data/spec/concurrent/channel/probe_spec.rb

@@ -1,33 +1,53 @@
 require 'spec_helper'
+require_relative '../observable_shared'
 
 module Concurrent
 
-  describe Probe do
+  describe Channel::Probe do
 
-    let(:probe) { Probe.new }
+    let(:channel) { Object.new }
+    let(:probe) { Channel::Probe.new }
+
+    describe 'behavior' do
+
+      # observable
+      
+      subject{ Channel::Probe.new }
+      
+      def trigger_observable(observable)
+        observable.set('value')
+      end
+
+      it_should_behave_like :observable
+    end
 
     describe '#set_unless_assigned' do
       context 'empty probe' do
         it 'assigns the value' do
-          probe.set_unless_assigned(32)
+          probe.set_unless_assigned(32, channel)
           probe.value.should eq 32
         end
 
+        it 'assign the channel' do
+          probe.set_unless_assigned(32, channel)
+          probe.channel.should be channel
+        end
+
         it 'returns true' do
-          probe.set_unless_assigned('hi').should eq true
+          probe.set_unless_assigned('hi', channel).should eq true
         end
       end
 
       context 'fulfilled probe' do
-        before(:each) { probe.set(27) }
+        before(:each) { probe.set([27, nil]) }
 
         it 'does not assign the value' do
-          probe.set_unless_assigned(88)
+          probe.set_unless_assigned(88, channel)
           probe.value.should eq 27
         end
 
         it 'returns false' do
-          probe.set_unless_assigned('hello').should eq false
+          probe.set_unless_assigned('hello', channel).should eq false
         end
       end
 
@@ -35,12 +55,20 @@ module Concurrent
         before(:each) { probe.fail }
 
         it 'does not assign the value' do
-          probe.set_unless_assigned(88)
+          probe.set_unless_assigned(88, channel)
           probe.should be_rejected
         end
 
+        it 'has a nil value' do
+          probe.value.should be_nil
+        end
+
+        it 'has a nil channel' do
+          probe.channel.should be_nil
+        end
+
         it 'returns false' do
-          probe.set_unless_assigned('hello').should eq false
+          probe.set_unless_assigned('hello', channel).should eq false
         end
       end
     end

data/spec/concurrent/channel/unbuffered_channel_spec.rb

@@ -5,7 +5,7 @@ module Concurrent
   describe UnbufferedChannel do
 
     let!(:channel) { subject }
-    let(:probe) { Probe.new }
+    let(:probe) { Channel::Probe.new }
 
     context 'with one thread' do
 
@@ -97,7 +97,7 @@ module Concurrent
 
         t.status.should eq 'sleep'
 
-        new_probe = Probe.new
+        new_probe = Channel::Probe.new
 
         channel.select(new_probe)
 

data/spec/concurrent/collection/priority_queue_spec.rb

@@ -0,0 +1,317 @@
+require 'spec_helper'
+
+share_examples_for :priority_queue do
+
+  subject{ described_class.new }
+
+  context '#initialize' do
+
+    it 'sorts from high to low when :order is :max' do
+      subject = described_class.from_list([2, 1, 4, 5, 3, 0], order: :max)
+      subject.pop.should eq 5
+      subject.pop.should eq 4
+      subject.pop.should eq 3
+    end
+
+    it 'sorts from high to low when :order is :high' do
+      subject = described_class.new(order: :high)
+      [2, 1, 4, 5, 3, 0].each{|item| subject << item }
+      subject.pop.should eq 5
+      subject.pop.should eq 4
+      subject.pop.should eq 3
+    end
+
+    it 'sorts from low to high when :order is :min' do
+      subject = described_class.from_list([2, 1, 4, 5, 3, 0], order: :min)
+      subject.pop.should eq 0
+      subject.pop.should eq 1
+      subject.pop.should eq 2
+    end
+
+    it 'sorts from low to high when :order is :low' do
+      subject = described_class.new(order: :low)
+      [2, 1, 4, 5, 3, 0].each{|item| subject << item }
+      subject.pop.should eq 0
+      subject.pop.should eq 1
+      subject.pop.should eq 2
+    end
+
+    it 'sorts from high to low by default' do
+      subject = described_class.new
+      subject = described_class.from_list([2, 1, 4, 5, 3, 0])
+      subject.pop.should eq 5
+      subject.pop.should eq 4
+      subject.pop.should eq 3
+    end
+  end
+
+  context '#clear' do
+
+    it 'removes all items from a populated queue' do
+      10.times{|i| subject << i}
+      subject.clear
+      subject.should be_empty
+    end
+
+    it 'has no effect on an empty queue' do
+      subject.clear
+      subject.should be_empty
+    end
+
+    specify { subject.clear.should be_true }
+  end
+
+  context '#delete' do
+
+    it 'deletes the requested item when found' do
+      10.times{|item| subject << item }
+      subject.delete(5)
+      subject.pop.should eq 9
+      subject.pop.should eq 8
+      subject.pop.should eq 7
+      subject.pop.should eq 6
+      subject.pop.should eq 4
+      subject.pop.should eq 3
+      subject.pop.should eq 2
+      subject.pop.should eq 1
+      subject.pop.should eq 0
+    end
+
+    it 'deletes the requested item when it is the first element' do
+      10.times{|item| subject << item }
+      subject.delete(9)
+      subject.length.should eq 9
+      subject.pop.should eq 8
+      subject.pop.should eq 7
+      subject.pop.should eq 6
+      subject.pop.should eq 5
+      subject.pop.should eq 4
+      subject.pop.should eq 3
+      subject.pop.should eq 2
+      subject.pop.should eq 1
+      subject.pop.should eq 0
+    end
+
+    it 'deletes the requested item when it is the last element' do
+      10.times{|item| subject << item }
+      subject.delete(2)
+      subject.length.should eq 9
+      subject.pop.should eq 9
+      subject.pop.should eq 8
+      subject.pop.should eq 7
+      subject.pop.should eq 6
+      subject.pop.should eq 5
+      subject.pop.should eq 4
+      subject.pop.should eq 3
+      subject.pop.should eq 1
+      subject.pop.should eq 0
+    end
+
+    it 'deletes multiple matching items when present' do
+      [2, 1, 2, 2, 2, 3, 2].each{|item| subject << item }
+      subject.delete(2)
+      subject.pop.should eq 3
+      subject.pop.should eq 1
+    end
+
+    it 'returns true when found' do
+      10.times{|i| subject << i}
+      subject.delete(2).should be_true
+    end
+
+    it 'returns false when not found' do
+      10.times{|i| subject << i}
+      subject.delete(100).should be_false
+    end
+
+    it 'returns false when called on an empty queue' do
+      subject.delete(:foo).should be_false
+    end
+  end
+
+  context '#empty?' do
+
+    it 'returns true for an empty queue' do
+      subject.should be_empty
+    end
+
+    it 'returns false for a populated queue' do
+      10.times{|i| subject << i}
+      subject.should_not be_empty
+    end
+  end
+
+  context '#include?' do
+
+    it 'returns true if the item is found' do
+      10.times{|i| subject << i}
+      subject.should include(5)
+    end
+
+    it 'returns false if the item is not found' do
+      10.times{|i| subject << i}
+      subject.should_not include(50)
+    end
+
+    it 'returns false when the queue is empty' do
+      subject.should_not include(1)
+    end
+
+    it 'is aliased as #has_priority?' do
+      10.times{|i| subject << i}
+      subject.should have_priority(5)
+    end
+  end
+
+  context '#length' do
+
+    it 'returns the length of a populated queue' do
+      10.times{|i| subject << i}
+      subject.length.should eq 10
+    end
+
+    it 'returns zero when the queue is empty' do
+      subject.length.should eq 0
+    end
+
+    it 'is aliased as #size' do
+      10.times{|i| subject << i}
+      subject.size.should eq 10
+    end
+  end
+
+  context '#peek' do
+
+    it 'returns the item at the head of the queue' do
+      10.times{|i| subject << i}
+      subject.peek.should eq 9
+    end
+
+    it 'does not remove the item from the queue' do
+      10.times{|i| subject << i}
+      subject.peek
+      subject.length.should eq 10
+      subject.should include(9)
+    end
+
+    it 'returns nil when the queue is empty' do
+      subject.peek.should be_nil
+    end
+  end
+
+  context '#pop' do
+
+    it 'returns the item at the head of the queue' do
+      10.times{|i| subject << i}
+      subject.pop.should eq 9
+    end
+
+    it 'removes the item from the queue' do
+      10.times{|i| subject << i}
+      subject.pop
+      subject.length.should eq 9
+      subject.should_not include(9)
+    end
+
+    it 'returns nil when the queue is empty' do
+      subject.pop.should be_nil
+    end
+
+    it 'is aliased as #deq' do
+      10.times{|i| subject << i}
+      subject.deq.should eq 9
+    end
+
+    it 'is aliased as #shift' do
+      10.times{|i| subject << i}
+      subject.shift.should eq 9
+    end
+  end
+
+  context '#push' do
+
+    it 'adds the item to the queue' do
+      subject.push(1)
+      subject.should include(1)
+    end
+
+    it 'sorts the new item in priority order' do
+      3.times{|i| subject << i}
+      subject.pop.should eq 2
+      subject.pop.should eq 1
+      subject.pop.should eq 0
+    end
+
+    it 'arbitrarily orders equal items with respect to each other' do
+      3.times{|i| subject << i}
+      subject.push(1)
+      subject.pop.should eq 2
+      subject.pop.should eq 1
+      subject.pop.should eq 1
+      subject.pop.should eq 0
+    end
+
+    specify { subject.push(10).should be_true }
+
+    it 'is aliased as <<' do
+      subject << 1
+      subject.should include(1)
+    end
+
+    it 'is aliased as enq' do
+      subject.enq(1)
+      subject.should include(1)
+    end
+  end
+
+  context '.from_list' do
+
+    it 'creates an empty queue from an empty list' do
+      subject = described_class.from_list([])
+      subject.should be_empty
+    end
+
+    it 'creates a sorted, populated queue from an Array' do
+      subject = described_class.from_list([2, 1, 4, 5, 3, 0])
+      subject.pop.should eq 5
+      subject.pop.should eq 4
+      subject.pop.should eq 3
+      subject.pop.should eq 2
+      subject.pop.should eq 1
+      subject.pop.should eq 0
+    end
+
+    it 'creates a sorted, populated queue from a Hash' do
+      subject = described_class.from_list(two: 2, one: 1, three: 3, zero: 0)
+      subject.length.should eq 4
+    end
+  end
+end
+
+module Concurrent
+
+  describe MutexPriorityQueue do
+
+    it_should_behave_like :priority_queue
+  end
+
+  if jruby?
+
+    describe JavaPriorityQueue do
+
+      it_should_behave_like :priority_queue
+    end
+  end
+
+  describe PriorityQueue do
+    if jruby?
+      it 'inherits from JavaPriorityQueue' do
+        PriorityQueue.ancestors.should include(JavaPriorityQueue)
+      end
+    else
+      it 'inherits from MutexPriorityQueue' do
+        PriorityQueue.ancestors.should include(MutexPriorityQueue)
+      end
+    end
+  end
+end