refactored channel specs.

Author: jdantonio

spec/concurrent/channel/buffered_channel_spec.rb

@@ -4,144 +4,139 @@ module Channel
     describe BufferedChannel do
 
       let(:size) { 2 }
-      let!(:channel) { BufferedChannel.new(size) }
+      subject { described_class.new(size) }
       let(:probe) { Channel::Probe.new }
 
       context 'without timeout' do
 
         describe '#push' do
           it 'adds elements to buffer' do
-            expect(channel.buffer_queue_size).to be 0
+            expect(subject.buffer_queue_size).to be 0
 
-            channel.push('a')
-            channel.push('a')
+            subject.push('a')
+            subject.push('a')
 
-            expect(channel.buffer_queue_size).to be 2
+            expect(subject.buffer_queue_size).to be 2
           end
 
           it 'should block when buffer is full' do
-            channel.push 1
-            channel.push 2
+            subject.push 1
+            subject.push 2
 
-            t = Thread.new { channel.push 3 }
+            t = Thread.new { subject.push 3 }
             t.join(0.1)
             expect(t.status).to eq 'sleep'
           end
 
           it 'restarts thread when buffer is no more full' do
-            channel.push 'hi'
-            channel.push 'foo'
+            subject.push 'hi'
+            subject.push 'foo'
 
             result = nil
 
-            t = Thread.new { channel.push 'bar'; result = 42 }
+            t = Thread.new { subject.push 'bar'; result = 42 }
 
             t.join(0.1)
-            channel.pop
+            subject.pop
             t.join(0.1)
 
             expect(result).to eq 42
           end
 
           it 'should assign value to a probe if probe set is not empty' do
-            channel.select(probe)
-            Thread.new { sleep(0.1); channel.push 3 }
+            subject.select(probe)
+            Thread.new { sleep(0.1); subject.push 3 }
             expect(probe.value.first).to eq 3
           end
         end
 
         describe '#pop' do
           it 'should block if buffer is empty' do
-            t = Thread.new { channel.pop }
+            t = Thread.new { subject.pop }
             t.join(0.1)
             expect(t.status).to eq 'sleep'
           end
 
           it 'returns value if buffer is not empty' do
-            channel.push 1
-            result = channel.pop
+            subject.push 1
+            result = subject.pop
 
             expect(result.first).to eq 1
           end
 
           it 'removes the first value from the buffer' do
-            channel.push 'a'
-            channel.push 'b'
+            subject.push 'a'
+            subject.push 'b'
 
-            expect(channel.pop.first).to eq 'a'
-            expect(channel.buffer_queue_size).to eq 1
+            expect(subject.pop.first).to eq 'a'
+            expect(subject.buffer_queue_size).to eq 1
           end
         end
-
       end
 
       describe 'select' do
 
         it 'does not block' do
-          t = Thread.new { channel.select(probe) }
+          t = Thread.new { subject.select(probe) }
           t.join(0.1)
           expect(t.status).to eq false
         end
 
         it 'gets notified by writer thread' do
-          channel.select(probe)
+          subject.select(probe)
 
-          Thread.new { channel.push 82 }
+          Thread.new { subject.push 82 }
 
           expect(probe.value.first).to eq 82
         end
-
       end
 
       context 'already set probes' do
         context 'empty buffer' do
           it 'discards already set probes' do
             probe.set('set value')
 
-            channel.select(probe)
+            subject.select(probe)
 
-            channel.push 27
+            subject.push 27
 
-            expect(channel.buffer_queue_size).to eq 1
-            expect(channel.probe_set_size).to eq 0
+            expect(subject.buffer_queue_size).to eq 1
+            expect(subject.probe_set_size).to eq 0
           end
         end
 
         context 'empty probe set' do
           it 'discards set probe' do
             probe.set('set value')
 
-            channel.push 82
-
-            channel.select(probe)
+            subject.push 82
 
-            expect(channel.buffer_queue_size).to eq 1
+            subject.select(probe)
 
-            expect(channel.pop.first).to eq 82
+            expect(subject.buffer_queue_size).to eq 1
 
+            expect(subject.pop.first).to eq 82
           end
         end
       end
 
       describe 'probe set' do
 
         it 'has size zero after creation' do
-          expect(channel.probe_set_size).to eq 0
+          expect(subject.probe_set_size).to eq 0
         end
 
         it 'increases size after a select' do
-          channel.select(probe)
-          expect(channel.probe_set_size).to eq 1
+          subject.select(probe)
+          expect(subject.probe_set_size).to eq 1
         end
 
         it 'decreases size after a removal' do
-          channel.select(probe)
-          channel.remove_probe(probe)
-          expect(channel.probe_set_size).to eq 0
+          subject.select(probe)
+          subject.remove_probe(probe)
+          expect(subject.probe_set_size).to eq 0
         end
-
       end
-
     end
   end
 end

spec/concurrent/channel/unbuffered_channel_spec.rb

@@ -3,7 +3,7 @@ module Channel
 
     describe UnbufferedChannel do
 
-      let!(:channel) { subject }
+      subject { described_class.new }
       let(:probe) { Channel::Probe.new }
 
       context 'with one thread' do
@@ -12,22 +12,20 @@ module Channel
 
           describe '#push' do
             it 'should block' do
-              t = Thread.new { channel.push 5 }
+              t = Thread.new { subject.push 5 }
               t.join(0.1)
               expect(t.status).to eq 'sleep'
             end
           end
 
           describe '#pop' do
             it 'should block' do
-              t = Thread.new { channel.pop }
+              t = Thread.new { subject.pop }
               t.join(0.1)
               expect(t.status).to eq 'sleep'
             end
           end
-
         end
-
       end
 
       context 'cooperating threads' do
@@ -38,8 +36,8 @@ module Channel
 
           result = nil
 
-          Thread.new { push_latch.wait(1); channel.push(42) }
-          Thread.new { push_latch.count_down; result = channel.pop; pop_latch.count_down }
+          Thread.new { push_latch.wait(1); subject.push(42) }
+          Thread.new { push_latch.count_down; result = subject.pop; pop_latch.count_down }
 
           pop_latch.wait(1)
           expect(result.first).to eq 42
@@ -49,10 +47,10 @@ module Channel
           result = Concurrent::AtomicFixnum.new(0)
 
           threads = [
-            Thread.new { channel.push 37 },
-            Thread.new { channel.pop; result.increment },
-            Thread.new { channel.pop; result.increment },
-            Thread.new { channel.pop; result.increment }
+            Thread.new { subject.push 37 },
+            Thread.new { subject.pop; result.increment },
+            Thread.new { subject.pop; result.increment },
+            Thread.new { subject.pop; result.increment }
           ]
 
           threads.each{|t| t.join(0.1) }
@@ -64,8 +62,8 @@ module Channel
           result = nil
 
           threads = [
-            Thread.new { result = channel.pop; },
-            Thread.new { channel.push 57 }
+            Thread.new { result = subject.pop; },
+            Thread.new { subject.push 57 }
           ]
 
           threads.each{|t| t.join(0.1) }
@@ -77,60 +75,56 @@ module Channel
       describe 'select' do
 
         it 'does not block' do
-          t = Thread.new { channel.select(probe) }
+          t = Thread.new { subject.select(probe) }
           t.join(0.1)
 
           expect(t.status).to eq false
         end
 
         it 'gets notified by writer thread' do
-          channel.select(probe)
+          subject.select(probe)
 
-          Thread.new { channel.push 82 }
+          Thread.new { subject.push 82 }
 
           expect(probe.value.first).to eq 82
         end
 
         it 'ignores already set probes and waits for a new one' do
           probe.set(27)
 
-          channel.select(probe)
+          subject.select(probe)
 
-          t = Thread.new { channel.push 72 }
+          t = Thread.new { subject.push 72 }
           t.join(0.1)
 
           expect(t.status).to eq 'sleep'
 
           new_probe = Channel::Probe.new
 
-          channel.select(new_probe)
+          subject.select(new_probe)
           t.join(0.1)
 
           expect(new_probe.value.first).to eq 72
         end
-
       end
 
       describe 'probe set' do
 
         it 'has size zero after creation' do
-          expect(channel.probe_set_size).to eq 0
+          expect(subject.probe_set_size).to eq 0
         end
 
         it 'increases size after a select' do
-          channel.select(probe)
-          expect(channel.probe_set_size).to eq 1
+          subject.select(probe)
+          expect(subject.probe_set_size).to eq 1
         end
 
         it 'decreases size after a removal' do
-          channel.select(probe)
-          channel.remove_probe(probe)
-          expect(channel.probe_set_size).to eq 0
+          subject.select(probe)
+          subject.remove_probe(probe)
+          expect(subject.probe_set_size).to eq 0
         end
-
       end
-
-
     end
   end
 end