in_threads 1.2.2 → 1.3.0

data/spec/in_threads_spec.rb

@@ -1,29 +1,38 @@
-$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-require 'rspec'
+require 'spec_helper'
 require 'in_threads'
 
-class Item
-  def initialize(i)
-    @i, @value = i, Kernel.rand
+# Test item with value
+class ValueItem
+  # Use fast_check? for matching
+  module FastCheckMatcher
+    def self.===(item)
+      unless item.respond_to?(:fast_check?)
+        fail "#{item.inspect} doesn't respont to fast_check?"
+      end
+      item.fast_check?
+    end
   end
 
-  def ==(other)
-    self.id == other.id
+  def initialize(i, value)
+    @i, @value = i, value
   end
 
-  class HalfMatcher
-    def ===(item)
-      raise "#{item.inspect} is not an Item" unless item.is_a?(Item)
-      (0.25..0.75) === item.instance_variable_get(:@value)
-    end
+  def ==(other)
+    id == other.id
   end
 
   def value
-    sleep; @value
+    sleep
+    @value
   end
 
   def check?
-    value < 0.5
+    sleep
+    fast_check?
+  end
+
+  def fast_check?
+    !!@value
   end
 
   def touch_n_value(*args)
@@ -47,35 +56,48 @@ private
   end
 end
 
-class ValueItem < Item
-  def initialize(i, value)
-    @i, @value = i, value
+# Test item with random value
+class RandItem < ValueItem
+  def initialize(i)
+    super(i, Kernel.rand)
   end
 
-  def value
-    sleep; @value
+  def fast_check?
+    @value < 0.5
   end
+end
 
-  def check?
-    !!value
+# Create custom Enumerables
+module CustomEnum
+  def self.new(&block)
+    Class.new do
+      include Enumerable
+      define_method :each, &block
+    end.new
   end
 end
 
+class TestException < StandardError; end
+
 def describe_enum_method(method, &block)
   @enum_methods ||= Enumerable.instance_methods.map(&:to_s)
   if @enum_methods.include?(method)
     describe(method, &block)
   else
-    it "should not be defined" do
-      exception_regexp = /^undefined method `#{Regexp.escape(method)}' .*\bInThreads\b/
-      expect{ enum.in_threads.send(method) }.to raise_error(NoMethodError, exception_regexp)
+    it 'should not be defined' do
+      exception_regexp =
+        /^undefined method `#{Regexp.escape(method)}' .*\bInThreads\b/
+      expect{ enum.in_threads.send(method) }.
+        to raise_error(NoMethodError, exception_regexp)
     end
   end
 end
 
-describe "in_threads" do
-  let(:enum){ 30.times.map{ |i| Item.new(i) } }
-  let(:speed_coef){ 0.666 } # small coefficient, should be more if sleep time coefficient is bigger
+describe 'in_threads' do
+  let(:enum){ 30.times.map{ |i| RandItem.new(i) } }
+
+  # small coefficient, should be more if sleep time coefficient is bigger
+  let(:speed_coef){ 0.666 }
 
   def measure
     start = Time.now
@@ -83,34 +105,35 @@ describe "in_threads" do
     Time.now - start
   end
 
-  describe "consistency" do
-    describe "verifying params" do
-      it "should complain about using with non enumerable" do
+  describe 'consistency' do
+    describe 'verifying params' do
+      it 'should complain about using with non enumerable' do
         expect{ InThreads.new(1) }.to raise_error(ArgumentError)
       end
 
       [1..10, 10.times, {}, []].each do |o|
-        it "should complain about using with #{o.class}" do
+        it "should not complain about using with #{o.class}" do
           expect{ InThreads.new(o) }.not_to raise_error
         end
       end
 
-      it "should complain about using less than 2 threads" do
+      it 'should complain about using less than 2 threads' do
         expect{ 10.times.in_threads(1) }.to raise_error(ArgumentError)
       end
 
-      it "should not complain about using 2 or more threads" do
+      it 'should not complain about using 2 or more threads' do
         expect{ 10.times.in_threads(2) }.not_to raise_error
       end
     end
 
-    describe "in_threads method" do
-      it "should not change existing instance" do
+    describe 'in_threads method' do
+      it 'should not change existing instance' do
         threaded = enum.in_threads(10)
         expect{ threaded.in_threads(20) }.not_to change(threaded, :thread_count)
       end
 
-      it "should create new instance with different title when called on WithProgress" do
+      it 'should create new instance with different title when called on '\
+          'WithProgress' do
         threaded = enum.in_threads(10)
         tthreaded = threaded.in_threads(20)
         expect(threaded.thread_count).to eq(10)
@@ -121,7 +144,7 @@ describe "in_threads" do
       end
     end
 
-    describe "thread count" do
+    describe 'thread count' do
       let(:enum){ 100.times.map{ |i| ValueItem.new(i, i < 50) } }
 
       %w[each map all?].each do |method|
@@ -146,104 +169,113 @@ describe "in_threads" do
       end
     end
 
-    describe "underlying enumerable usage" do
-      class CheckEachCalls
-        include Enumerable
-
-        def each
-          each_started
-          100.times.each do |i|
-            yield ValueItem.new(i, i < 50)
+    describe 'underlying enumerable usage' do
+      %w[each map all?].each do |method|
+        it "should call underlying enumerable.each only once for #{method}" do
+          enum = CustomEnum.new do |&block|
+            100.times.each do |i|
+              block[ValueItem.new(i, i < 50)]
+            end
           end
+
+          expect(enum).to receive(:each).once.and_call_original
+          enum.in_threads(13).send(method, &:check?)
         end
       end
-      let(:enum){ CheckEachCalls.new }
 
-      %w[each map all?].each do |method|
-        it "should call underlying enumerable.each only once for #{method}" do
-          expect(enum).to receive(:each_started).once
-          enum.in_threads(13).send(method, &:check?)
+      it 'should not yield all elements when not needed' do
+        enum = CustomEnum.new do |&block|
+          100.times{ block[1] }
+          fail
         end
+
+        enum.in_threads(13).all?{ false }
       end
     end
   end
 
-  describe "methods" do
-    (Enumerable.instance_methods - 10.times.in_threads.class.instance_methods).each do |method|
+  describe 'methods' do
+    enumerable_methods = Enumerable.instance_methods
+    in_threads_methods = 10.times.in_threads.class.instance_methods
+    (enumerable_methods - in_threads_methods).each do |method|
       pending method
     end
 
-    class TestException < StandardError; end
-
     def check_test_exception(enum, &block)
       expect{ block[enum.in_threads] }.to raise_exception(TestException)
       expect{ block[enum.in_threads(1000)] }.to raise_exception(TestException)
     end
 
-    describe "each" do
-      it "should return same enum after running" do
+    describe 'each' do
+      it 'should return same enum after running' do
         expect(enum.in_threads.each(&:value)).to eq(enum)
       end
 
-      it "should execute block for each element" do
+      it 'should execute block for each element' do
         enum.each{ |o| expect(o).to receive(:touch).once }
         enum.in_threads.each(&:touch_n_value)
       end
 
-      it "should run faster with threads" do
-        expect(measure{ enum.in_threads.each(&:value) }).to be < measure{ enum.each(&:value) } * speed_coef
+      it 'should run faster with threads' do
+        expect(measure{ enum.in_threads.each(&:value) }).
+          to be < measure{ enum.each(&:value) } * speed_coef
       end
 
-      it "should run faster with more threads" do
-        expect(measure{ enum.in_threads(10).each(&:value) }).to be < measure{ enum.in_threads(2).each(&:value) } * speed_coef
+      it 'should run faster with more threads' do
+        expect(measure{ enum.in_threads(10).each(&:value) }).
+          to be < measure{ enum.in_threads(2).each(&:value) } * speed_coef
       end
 
-      it "should return same enum without block" do
+      it 'should return same enum without block' do
         expect(enum.in_threads.each.to_a).to eq(enum.each.to_a)
       end
 
-      it "should raise exception in outer thread" do
+      it 'should raise exception in outer thread' do
         check_test_exception(enum) do |threaded|
-          threaded.each{ raise TestException }
+          threaded.each{ fail TestException }
         end
       end
     end
 
     %w[each_with_index enum_with_index].each do |method|
       describe_enum_method method do
-        let(:runner){ proc{ |o, i| o.value } }
+        let(:runner){ proc{ |o, _i| o.value } }
 
-        it "should return same result with threads" do
-          expect(enum.in_threads.send(method, &runner)).to eq(enum.send(method, &runner))
+        it 'should return same result with threads' do
+          expect(enum.in_threads.send(method, &runner)).
+            to eq(enum.send(method, &runner))
         end
 
-        it "should fire same objects" do
+        it 'should fire same objects' do
           enum.send(method){ |o, i| expect(o).to receive(:touch).with(i).once }
           enum.in_threads.send(method){ |o, i| o.touch_n_value(i) }
         end
 
-        it "should run faster with threads" do
-          expect(measure{ enum.in_threads.send(method, &runner) }).to be < measure{ enum.send(method, &runner) } * speed_coef
+        it 'should run faster with threads' do
+          expect(measure{ enum.in_threads.send(method, &runner) }).
+            to be < measure{ enum.send(method, &runner) } * speed_coef
         end
 
-        it "should return same enum without block" do
-          expect(enum.in_threads.send(method).to_a).to eq(enum.send(method).to_a)
+        it 'should return same enum without block' do
+          expect(enum.in_threads.send(method).to_a).
+            to eq(enum.send(method).to_a)
         end
 
-        it "should raise exception in outer thread" do
+        it 'should raise exception in outer thread' do
           check_test_exception(enum) do |threaded|
-            threaded.send(method){ raise TestException }
+            threaded.send(method){ fail TestException }
           end
         end
       end
     end
 
-    describe "reverse_each" do
-      it "should return same result with threads" do
-        expect(enum.in_threads.reverse_each(&:value)).to eq(enum.reverse_each(&:value))
+    describe 'reverse_each' do
+      it 'should return same result with threads' do
+        expect(enum.in_threads.reverse_each(&:value)).
+          to eq(enum.reverse_each(&:value))
       end
 
-      it "should fire same objects in reverse order" do
+      it 'should fire same objects in reverse order' do
         @order = double('order', :notify => nil)
         expect(@order).to receive(:notify).with(enum.last).ordered
         expect(@order).to receive(:notify).with(enum[enum.length / 2]).ordered
@@ -256,17 +288,18 @@ describe "in_threads" do
         end
       end
 
-      it "should run faster with threads" do
-        expect(measure{ enum.in_threads.reverse_each(&:value) }).to be < measure{ enum.reverse_each(&:value) } * speed_coef
+      it 'should run faster with threads' do
+        expect(measure{ enum.in_threads.reverse_each(&:value) }).
+          to be < measure{ enum.reverse_each(&:value) } * speed_coef
       end
 
-      it "should return same enum without block" do
+      it 'should return same enum without block' do
         expect(enum.in_threads.reverse_each.to_a).to eq(enum.reverse_each.to_a)
       end
 
-      it "should raise exception in outer thread" do
+      it 'should raise exception in outer thread' do
         check_test_exception(enum) do |threaded|
-          threaded.reverse_each{ raise TestException }
+          threaded.reverse_each{ fail TestException }
         end
       end
     end
@@ -276,13 +309,14 @@ describe "in_threads" do
       detect find find_index drop_while take_while
     ].each do |method|
       describe method do
-        let(:enum){ 100.times.map{ |i| ValueItem.new(i, i % 2 == 1) } }
+        let(:enum){ 100.times.map{ |i| ValueItem.new(i, i.odd?) } }
 
-        it "should return same result with threads" do
-          expect(enum.in_threads.send(method, &:check?)).to eq(enum.send(method, &:check?))
+        it 'should return same result with threads' do
+          expect(enum.in_threads.send(method, &:check?)).
+            to eq(enum.send(method, &:check?))
         end
 
-        it "should fire same objects but not all" do
+        it 'should fire same objects but not all' do
           a = []
           enum.send(method) do |o|
             a << o
@@ -291,21 +325,25 @@ describe "in_threads" do
 
           @a = []
           @mutex = Mutex.new
-          enum.in_threads.send(method){ |o| @mutex.synchronize{ @a << o }; o.check? }
+          enum.in_threads.send(method) do |o|
+            @mutex.synchronize{ @a << o }
+            o.check?
+          end
 
           expect(@a.length).to be >= a.length
           expect(@a.length).to be <= enum.length * 0.5
         end
 
-        it "should run faster with threads" do
+        it 'should run faster with threads' do
           boolean = %w[all? drop_while take_while].include?(method)
           enum = 30.times.map{ |i| ValueItem.new(i, boolean) }
-          expect(measure{ enum.in_threads.send(method, &:check?) }).to be < measure{ enum.send(method, &:check?) } * speed_coef
+          expect(measure{ enum.in_threads.send(method, &:check?) }).
+            to be < measure{ enum.send(method, &:check?) } * speed_coef
         end
 
-        it "should raise exception in outer thread" do
+        it 'should raise exception in outer thread' do
           check_test_exception(enum) do |threaded|
-            threaded.send(method){ raise TestException }
+            threaded.send(method){ fail TestException }
           end
         end
       end
@@ -313,22 +351,24 @@ describe "in_threads" do
 
     %w[partition find_all select reject count].each do |method|
       describe method do
-        it "should return same result with threads" do
-          expect(enum.in_threads.send(method, &:check?)).to eq(enum.send(method, &:check?))
+        it 'should return same result with threads' do
+          expect(enum.in_threads.send(method, &:check?)).
+            to eq(enum.send(method, &:check?))
         end
 
-        it "should fire same objects" do
+        it 'should fire same objects' do
           enum.send(method){ |o| expect(o).to receive(:touch).once }
           enum.in_threads.send(method, &:touch_n_check?)
         end
 
-        it "should run faster with threads" do
-          expect(measure{ enum.in_threads.send(method, &:check?) }).to be < measure{ enum.send(method, &:check?) } * speed_coef
+        it 'should run faster with threads' do
+          expect(measure{ enum.in_threads.send(method, &:check?) }).
+            to be < measure{ enum.send(method, &:check?) } * speed_coef
         end
 
-        it "should raise exception in outer thread" do
+        it 'should raise exception in outer thread' do
           check_test_exception(enum) do |threaded|
-            threaded.send(method){ raise TestException }
+            threaded.send(method){ fail TestException }
           end
         end
       end
@@ -336,22 +376,24 @@ describe "in_threads" do
 
     %w[collect map group_by max_by min_by minmax_by sort_by].each do |method|
       describe method do
-        it "should return same result with threads" do
-          expect(enum.in_threads.send(method, &:value)).to eq(enum.send(method, &:value))
+        it 'should return same result with threads' do
+          expect(enum.in_threads.send(method, &:value)).
+            to eq(enum.send(method, &:value))
         end
 
-        it "should fire same objects" do
+        it 'should fire same objects' do
           enum.send(method){ |o| expect(o).to receive(:touch).once; 0 }
           enum.in_threads.send(method, &:touch_n_value)
         end
 
-        it "should run faster with threads" do
-          expect(measure{ enum.in_threads.send(method, &:value) }).to be < measure{ enum.send(method, &:value) } * speed_coef
+        it 'should run faster with threads' do
+          expect(measure{ enum.in_threads.send(method, &:value) }).
+            to be < measure{ enum.send(method, &:value) } * speed_coef
         end
 
-        it "should raise exception in outer thread" do
+        it 'should raise exception in outer thread' do
           check_test_exception(enum) do |threaded|
-            threaded.send(method){ raise TestException }
+            threaded.send(method){ fail TestException }
           end
         end
       end
@@ -361,191 +403,220 @@ describe "in_threads" do
       describe_enum_method method do
         let(:runner){ proc{ |a| a.each(&:value) } }
 
-        it "should fire same objects" do
-          enum.send(method, 3){ |a| expect(a.first).to receive(:touch).with(a).once }
+        it 'should fire same objects' do
+          enum.send(method, 3) do |a|
+            expect(a.first).to receive(:touch).with(a).once
+          end
           enum.in_threads.send(method, 3){ |a| a.first.touch_n_value(a) }
         end
 
-        it "should return same with block" do
-          expect(enum.in_threads.send(method, 3, &runner)).to eq(enum.send(method, 3, &runner))
+        it 'should return same with block' do
+          expect(enum.in_threads.send(method, 3, &runner)).
+            to eq(enum.send(method, 3, &runner))
         end
 
-        it "should run faster with threads" do
-          expect(measure{ enum.in_threads.send(method, 3, &runner) }).to be < measure{ enum.send(method, 3, &runner) } * speed_coef
+        it 'should run faster with threads' do
+          expect(measure{ enum.in_threads.send(method, 3, &runner) }).
+            to be < measure{ enum.send(method, 3, &runner) } * speed_coef
         end
 
-        it "should return same without block" do
-          expect(enum.in_threads.send(method, 3).to_a).to eq(enum.send(method, 3).to_a)
+        it 'should return same without block' do
+          expect(enum.in_threads.send(method, 3).to_a).
+            to eq(enum.send(method, 3).to_a)
         end
 
-        it "should raise exception in outer thread" do
+        it 'should raise exception in outer thread' do
           check_test_exception(enum) do |threaded|
-            threaded.send(method, 3){ raise TestException }
+            threaded.send(method, 3){ fail TestException }
           end
         end
       end
     end
 
-    describe "zip" do
+    describe 'zip' do
       let(:runner){ proc{ |a| a.each(&:value) } }
 
-      it "should fire same objects" do
-        enum.zip(enum, enum){ |a| expect(a.first).to receive(:touch).with(a).once }
-        enum.in_threads.zip(enum, enum){ |a| a.first.touch_n_value(a) }
+      it 'should fire same objects' do
+        enum.zip(enum, enum) do |a|
+          expect(a.first).to receive(:touch).with(a).once
+        end
+
+        enum.in_threads.zip(enum, enum) do |a|
+          a.first.touch_n_value(a)
+        end
       end
 
-      it "should return same with block" do
-        expect(enum.in_threads.zip(enum, enum, &runner)).to eq(enum.zip(enum, enum, &runner))
+      it 'should return same with block' do
+        expect(enum.in_threads.zip(enum, enum, &runner)).
+          to eq(enum.zip(enum, enum, &runner))
       end
 
-      it "should run faster with threads" do
-        expect(measure{ enum.in_threads.zip(enum, enum, &runner) }).to be < measure{ enum.zip(enum, enum, &runner) } * speed_coef
+      it 'should run faster with threads' do
+        expect(measure{ enum.in_threads.zip(enum, enum, &runner) }).
+          to be < measure{ enum.zip(enum, enum, &runner) } * speed_coef
       end
 
-      it "should return same without block" do
+      it 'should return same without block' do
         expect(enum.in_threads.zip(enum, enum)).to eq(enum.zip(enum, enum))
       end
 
-      it "should raise exception in outer thread" do
+      it 'should raise exception in outer thread' do
         check_test_exception(enum) do |threaded|
-          threaded.zip(enum, enum){ raise TestException }
+          threaded.zip(enum, enum){ fail TestException }
         end
       end
     end
 
-    describe "cycle" do
-      it "should fire same objects" do
+    describe 'cycle' do
+      it 'should fire same objects' do
         enum.cycle(1){ |o| expect(o).to receive(:touch).exactly(3).times }
         enum.in_threads.cycle(3, &:touch_n_value)
       end
 
-      it "should run faster with threads" do
-        expect(measure{ enum.in_threads.cycle(3, &:value) }).to be < measure{ enum.cycle(3, &:value) } * speed_coef
+      it 'should run faster with threads' do
+        expect(measure{ enum.in_threads.cycle(3, &:value) }).
+          to be < measure{ enum.cycle(3, &:value) } * speed_coef
       end
 
-      it "should return same enum without block" do
+      it 'should return same enum without block' do
         expect(enum.in_threads.cycle(3).to_a).to eq(enum.cycle(3).to_a)
       end
 
-      it "should raise exception in outer thread" do
+      it 'should raise exception in outer thread' do
         check_test_exception(enum) do |threaded|
-          threaded.cycle{ raise TestException }
+          threaded.cycle{ fail TestException }
         end
       end
     end
 
-    describe "grep" do
-      let(:matcher){ Item::HalfMatcher.new }
+    describe 'grep' do
+      let(:matcher){ ValueItem::FastCheckMatcher }
 
-      it "should fire same objects" do
-        enum.each{ |o| expect(o).to receive(:touch).exactly(matcher === o ? 1 : 0).times }
+      it 'should fire same objects' do
+        enum.each do |o|
+          expect(o).to receive(:touch).exactly(o.fast_check? ? 1 : 0).times
+        end
         enum.in_threads.grep(matcher, &:touch_n_value)
       end
 
-      it "should return same with block" do
-        expect(enum.in_threads.grep(matcher, &:value)).to eq(enum.grep(matcher, &:value))
+      it 'should return same with block' do
+        expect(enum.in_threads.grep(matcher, &:value)).
+          to eq(enum.grep(matcher, &:value))
       end
 
-      it "should run faster with threads" do
-        expect(measure{ enum.in_threads.grep(matcher, &:value) }).to be < measure{ enum.grep(matcher, &:value) } * speed_coef
+      it 'should run faster with threads' do
+        expect(measure{ enum.in_threads.grep(matcher, &:value) }).
+          to be < measure{ enum.grep(matcher, &:value) } * speed_coef
       end
 
-      it "should return same without block" do
+      it 'should return same without block' do
         expect(enum.in_threads.grep(matcher)).to eq(enum.grep(matcher))
       end
 
-      it "should raise exception in outer thread" do
+      it 'should raise exception in outer thread' do
         check_test_exception(enum) do |threaded|
-          threaded.grep(matcher){ raise TestException }
+          threaded.grep(matcher){ fail TestException }
         end
       end
     end
 
-    describe_enum_method "each_entry" do
-      class EachEntryYielder
-        include Enumerable
-        def each
-          10.times{ yield 1 }
-          10.times{ yield 2, 3 }
-          10.times{ yield 4, 5, 6 }
+    describe_enum_method 'each_entry' do
+      let(:enum) do
+        CustomEnum.new do |&block|
+          10.times{ block[1] }
+          10.times{ block[2, 3] }
+          10.times{ block[4, 5, 6] }
         end
       end
-
-      let(:enum){ EachEntryYielder.new }
       let(:runner){ proc{ |o| ValueItem.new(0, o).value } }
 
-      it "should return same result with threads" do
-        expect(enum.in_threads.each_entry(&runner)).to eq(enum.each_entry(&runner))
+      it 'should return same result with threads' do
+        expect(enum.in_threads.each_entry(&runner)).
+          to eq(enum.each_entry(&runner))
       end
 
-      it "should execute block for each element" do
-        @order = double('order')
-        expect(@order).to receive(:notify).with(1).exactly(10).times.ordered
-        expect(@order).to receive(:notify).with([2, 3]).exactly(10).times.ordered
-        expect(@order).to receive(:notify).with([4, 5, 6]).exactly(10).times.ordered
+      it 'should execute block for each element' do
+        @o = double('order')
+        expect(@o).to receive(:notify).with(1).exactly(10).times.ordered
+        expect(@o).to receive(:notify).with([2, 3]).exactly(10).times.ordered
+        expect(@o).to receive(:notify).with([4, 5, 6]).exactly(10).times.ordered
         @mutex = Mutex.new
         enum.in_threads.each_entry do |o|
-          @mutex.synchronize{ @order.notify(o) }
+          @mutex.synchronize{ @o.notify(o) }
           runner[]
         end
       end
 
-      it "should run faster with threads" do
-        expect(measure{ enum.in_threads.each_entry(&runner) }).to be < measure{ enum.each_entry(&runner) } * speed_coef
+      it 'should run faster with threads' do
+        expect(measure{ enum.in_threads.each_entry(&runner) }).
+          to be < measure{ enum.each_entry(&runner) } * speed_coef
       end
 
-      it "should return same enum without block" do
+      it 'should return same enum without block' do
         expect(enum.in_threads.each_entry.to_a).to eq(enum.each_entry.to_a)
       end
 
-      it "should raise exception in outer thread" do
+      it 'should raise exception in outer thread' do
         check_test_exception(enum) do |threaded|
-          threaded.each_entry{ raise TestException }
+          threaded.each_entry{ fail TestException }
         end
       end
     end
 
     %w[flat_map collect_concat].each do |method|
       describe_enum_method method do
-        let(:enum){ 20.times.map{ |i| Item.new(i) }.each_slice(3) }
+        let(:enum){ 20.times.map{ |i| RandItem.new(i) }.each_slice(3) }
         let(:runner){ proc{ |a| a.map(&:value) } }
 
-        it "should return same result with threads" do
-          expect(enum.in_threads.send(method, &runner)).to eq(enum.send(method, &runner))
+        it 'should return same result with threads' do
+          expect(enum.in_threads.send(method, &runner)).
+            to eq(enum.send(method, &runner))
         end
 
-        it "should fire same objects" do
-          enum.send(method){ |a| a.each{ |o| expect(o).to receive(:touch).with(a).once } }
-          enum.in_threads.send(method){ |a| a.each{ |o| o.touch_n_value(a) } }
+        it 'should fire same objects' do
+          enum.send(method) do |a|
+            a.each do |o|
+              expect(o).to receive(:touch).with(a).once
+            end
+          end
+
+          enum.in_threads.send(method) do |a|
+            a.each do |o|
+              o.touch_n_value(a)
+            end
+          end
         end
 
-        it "should run faster with threads" do
-          expect(measure{ enum.in_threads.send(method, &runner) }).to be < measure{ enum.send(method, &runner) } * speed_coef
+        it 'should run faster with threads' do
+          expect(measure{ enum.in_threads.send(method, &runner) }).
+            to be < measure{ enum.send(method, &runner) } * speed_coef
         end
 
-        it "should return same enum without block" do
-          expect(enum.in_threads.send(method).to_a).to eq(enum.send(method).to_a)
+        it 'should return same enum without block' do
+          expect(enum.in_threads.send(method).to_a).
+            to eq(enum.send(method).to_a)
         end
 
-        it "should raise exception in outer thread" do
+        it 'should raise exception in outer thread' do
           check_test_exception(enum) do |threaded|
-            threaded.send(method){ raise TestException }
+            threaded.send(method){ fail TestException }
           end
         end
       end
     end
 
-    context "unthreaded" do
+    context 'unthreaded' do
       %w[inject reduce].each do |method|
         describe method do
-          it "should return same result" do
+          it 'should return same result' do
             combiner = proc{ |memo, o| memo + o.value }
-            expect(enum.in_threads.send(method, 0, &combiner)).to eq(enum.send(method, 0, &combiner))
+            expect(enum.in_threads.send(method, 0, &combiner)).
+              to eq(enum.send(method, 0, &combiner))
           end
 
-          it "should raise exception in outer thread" do
+          it 'should raise exception in outer thread' do
             check_test_exception(enum) do |threaded|
-              threaded.send(method){ raise TestException }
+              threaded.send(method){ fail TestException }
             end
           end
         end
@@ -553,14 +624,15 @@ describe "in_threads" do
 
       %w[max min minmax sort].each do |method|
         describe method do
-          it "should return same result" do
+          it 'should return same result' do
             comparer = proc{ |a, b| a.value <=> b.value }
-            expect(enum.in_threads.send(method, &comparer)).to eq(enum.send(method, &comparer))
+            expect(enum.in_threads.send(method, &comparer)).
+              to eq(enum.send(method, &comparer))
           end
 
-          it "should raise exception in outer thread" do
+          it 'should raise exception in outer thread' do
             check_test_exception(enum) do |threaded|
-              threaded.send(method){ raise TestException }
+              threaded.send(method){ fail TestException }
             end
           end
         end
@@ -568,7 +640,7 @@ describe "in_threads" do
 
       %w[to_a entries].each do |method|
         describe method do
-          it "should return same result" do
+          it 'should return same result' do
             expect(enum.in_threads.send(method)).to eq(enum.send(method))
           end
         end
@@ -576,7 +648,7 @@ describe "in_threads" do
 
       %w[drop take].each do |method|
         describe method do
-          it "should return same result" do
+          it 'should return same result' do
             expect(enum.in_threads.send(method, 2)).to eq(enum.send(method, 2))
           end
         end
@@ -584,7 +656,7 @@ describe "in_threads" do
 
       %w[first].each do |method|
         describe method do
-          it "should return same result" do
+          it 'should return same result' do
             expect(enum.in_threads.send(method)).to eq(enum.send(method))
             expect(enum.in_threads.send(method, 3)).to eq(enum.send(method, 3))
           end
@@ -593,35 +665,38 @@ describe "in_threads" do
 
       %w[include? member?].each do |method|
         describe method do
-          it "should return same result" do
-            expect(enum.in_threads.send(method, enum[10])).to eq(enum.send(method, enum[10]))
+          it 'should return same result' do
+            expect(enum.in_threads.send(method, enum[10])).
+              to eq(enum.send(method, enum[10]))
           end
         end
       end
 
-      describe_enum_method "each_with_object" do
+      describe_enum_method 'each_with_object' do
         let(:runner){ proc{ |o, h| h[o.value] = true } }
 
-        it "should return same result" do
-          expect(enum.in_threads.each_with_object({}, &runner)).to eq(enum.each_with_object({}, &runner))
+        it 'should return same result' do
+          expect(enum.in_threads.each_with_object({}, &runner)).
+            to eq(enum.each_with_object({}, &runner))
         end
 
-        it "should raise exception in outer thread" do
+        it 'should raise exception in outer thread' do
           check_test_exception(enum) do |threaded|
-            threaded.each_with_object({}){ raise TestException }
+            threaded.each_with_object({}){ fail TestException }
           end
         end
       end
 
       %w[chunk slice_before].each do |method|
         describe_enum_method method do
-          it "should return same result" do
-            expect(enum.in_threads.send(method, &:check?).to_a).to eq(enum.send(method, &:check?).to_a)
+          it 'should return same result' do
+            expect(enum.in_threads.send(method, &:check?).to_a).
+              to eq(enum.send(method, &:check?).to_a)
           end
 
-          it "should raise exception in outer thread" do
+          it 'should raise exception in outer thread' do
             check_test_exception(enum) do |threaded|
-              threaded.send(method){ raise TestException }.to_a
+              threaded.send(method){ fail TestException }.to_a
             end
           end
         end