async 1.26.1 → 1.26.2

data/spec/async/queue_spec.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright, 2017, by Samuel G. D. Williams. <http://www.codeotaku.com>
-# 
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-# 
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-
-require 'async'
-require 'async/queue'
-require 'async/rspec'
-require 'async/semaphore'
-
-require_relative 'condition_examples'
-require_relative 'chainable_async_examples'
-
-RSpec.shared_context Async::Queue do
-	it 'should process items in order' do
-		reactor.async do |task|
-			10.times do |i|
-				task.sleep(0.001)
-				subject.enqueue(i)
-			end
-		end
-		
-		10.times do |j|
-			expect(subject.dequeue).to be == j
-		end
-	end
-	
-	it 'can dequeue items asynchronously' do
-		reactor.async do |task|
-			subject << 1
-			subject << nil
-		end
-		
-		subject.async do |task, item|
-			expect(item).to be 1
-		end
-	end
-	
-	context 'with an empty queue' do
-		it {is_expected.to be_empty}
-	end
-	
-	context 'with semaphore' do
-		let(:capacity) {2}
-		let(:semaphore) {Async::Semaphore.new(capacity)}
-		let(:repeats) {capacity * 2}
-		
-		it 'should process several items limited by a semaphore' do
-			count = 0
-			
-			Async do
-				repeats.times do
-					subject.enqueue :item
-				end
-				
-				subject.enqueue nil
-			end
-			
-			subject.async(parent: semaphore) do |task|
-				count += 1
-			end
-			
-			expect(count).to be == repeats
-		end
-	end
-	
-	it_behaves_like 'chainable async' do
-		before do
-			subject.enqueue(:item)
-			
-			# The limited queue may block.
-			Async do
-				subject.enqueue(nil)
-			end
-		end
-	end
-end
-
-RSpec.describe Async::Queue do
-	include_context Async::RSpec::Reactor
-	
-	it_behaves_like Async::Queue
-end
-
-RSpec.describe Async::LimitedQueue do
-	include_context Async::RSpec::Reactor
-	
-	it_behaves_like Async::Queue
-	
-	it 'should become limited' do
-		expect(subject).to_not be_limited
-		subject.enqueue(10)
-		expect(subject).to be_limited
-	end
-
-	it 'should resume waiting tasks in order' do
-		total_resumed = 0
-		total_dequeued = 0
-		
-		Async do |producer|
-			10.times do
-				producer.async do
-					subject.enqueue('foo')
-					total_resumed += 1
-				end
-			end
-		end
-		
-		10.times do
-			item = subject.dequeue
-			total_dequeued += 1
-			
-			expect(total_resumed).to be == total_dequeued
-		end
-	end
-end

data/spec/async/reactor/nested_spec.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright, 2017, by Samuel G. D. Williams. <http://www.codeotaku.com>
-# 
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-# 
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-
-RSpec.describe Async::Reactor do
-	describe '::run (in existing reactor)' do
-		include_context Async::RSpec::Reactor
-		
-		it "should nest reactor" do
-			outer_reactor = Async::Task.current.reactor
-			inner_reactor = nil
-			
-			described_class.run do |task|
-				inner_reactor = task.reactor
-			end
-			
-			expect(outer_reactor).to be_kind_of(described_class)
-			expect(outer_reactor).to be_eql(inner_reactor)
-		end
-	end
-	
-	describe '::run' do
-		it "should nest reactor" do
-			expect(Async::Task.current?).to be_nil
-			inner_reactor = nil
-			
-			described_class.run do |task|
-				inner_reactor = task.reactor
-			end
-			
-			expect(inner_reactor).to be_kind_of(described_class)
-		end
-	end
-end

data/spec/async/reactor_spec.rb

@@ -1,253 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright, 2017, by Samuel G. D. Williams. <http://www.codeotaku.com>
-# 
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-# 
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-
-require 'async'
-require 'async/rspec/reactor'
-
-require 'benchmark/ips'
-
-RSpec.describe Async::Reactor do
-	describe '#run' do
-		it "can run tasks on different fibers" do
-			outer_fiber = Fiber.current
-			inner_fiber = nil
-			
-			described_class.run do |task|
-				task.sleep(0)
-				inner_fiber = Fiber.current
-			end
-			
-			expect(inner_fiber).to_not be nil
-			expect(outer_fiber).to_not be == inner_fiber
-		end
-	end
-	
-	describe '#close' do
-		it "can close empty reactor" do
-			subject.close
-			
-			expect(subject).to be_closed
-		end
-	end
-	
-	describe '#run_once' do
-		it "can run the reactor" do
-			# Run the reactor for 1 second:
-			task = subject.async do |task|
-				task.yield
-			end
-			
-			expect(task).to be_running
-			
-			# This will resume the task, and then the reactor will be finished.
-			expect(subject.run_once).to be false
-			
-			expect(task).to be_finished
-		end
-		
-		it "can run one iteration" do
-			state = nil
-	
-			subject.async do |task|
-				state = :started
-				task.yield
-				state = :finished
-			end
-	
-			expect(state).to be :started
-	
-			subject.run_once
-			expect(state).to be :finished
-		end
-	end
-	
-	describe '#print_hierarchy' do
-		it "can print hierarchy" do
-			subject.async do |parent|
-				parent.async do |child|
-					child.sleep 1
-				end
-				
-				parent.sleep 1
-			end
-			
-			output = StringIO.new
-			subject.print_hierarchy(output)
-			lines = output.string.lines
-			
-			expect(lines[0]).to be =~ /#<Async::Reactor.*(running)/
-			expect(lines[1]).to be =~ /\t#<Async::Task.*(running)/
-			expect(lines[2]).to be =~ /\t\t#<Async::Task.*(running)/
-		end
-	end
-	
-	describe '#stop' do
-		it "can stop the reactor" do
-			state = nil
-			
-			subject.async(annotation: "sleep(10)") do |task|
-				state = :started
-				task.sleep(10)
-				state = :stopped
-			end
-			
-			subject.async(annotation: "reactor.stop") do |task|
-				task.sleep(0.1)
-				task.reactor.stop
-			end
-			
-			subject.run
-			
-			expect(state).to be == :started
-			
-			subject.close
-		end
-		
-		it "can stop reactor from different thread" do
-			events = Thread::Queue.new
-			
-			thread = Thread.new do
-				if events.pop
-					subject.stop
-				end
-			end
-			
-			subject.async do |task|
-				events << true
-			end
-			
-			subject.run
-			
-			thread.join
-			
-			expect(subject).to be_stopped
-		end
-	end
-	
-	it "can't return" do
-		expect do
-			Async do |task|
-				return
-			end.wait
-		end.to raise_exception(LocalJumpError)
-	end
-	
-	it "is closed after running" do
-		reactor = nil
-		
-		Async do |task|
-			reactor = task.reactor
-		end
-		
-		expect(reactor).to be_closed
-		
-		expect{reactor.run}.to raise_exception(RuntimeError, /closed/)
-	end
-	
-	it "should return a task" do
-		result = Async do |task|
-		end
-		
-		expect(result).to be_kind_of(Async::Task)
-	end
-	
-	describe '#async' do
-		include_context Async::RSpec::Reactor
-		
-		it "can pass in arguments" do
-			reactor.async(:arg) do |task, arg|
-				expect(arg).to be == :arg
-			end.wait
-		end
-		
-		it "passes in the correct number of arguments" do
-			reactor.async(:arg1, :arg2, :arg3) do |task, arg1, arg2, arg3|
-				expect(arg1).to be == :arg1
-				expect(arg2).to be == :arg2
-				expect(arg3).to be == :arg3
-			end.wait
-		end
-	end
-	
-	describe '#with_timeout' do
-		let(:duration) {1}
-		
-		it "stops immediately" do
-			start_time = Time.now
-			
-			described_class.run do |task|
-				condition = Async::Condition.new
-				
-				task.with_timeout(duration) do
-					task.async do
-						condition.wait
-					end
-					
-					condition.signal
-					
-					task.yield
-					
-					task.children.each(&:wait)
-				end
-			end
-			
-			duration = Time.now - start_time
-			
-			expect(duration).to be < 0.1
-		end
-		
-		let(:timeout_class) {Class.new(RuntimeError)}
-		
-		it "raises specified exception" do
-			expect do
-				described_class.run do |task|
-					task.with_timeout(0.0, timeout_class) do
-						task.sleep(1.0)
-					end
-				end.wait
-			end.to raise_exception(timeout_class)
-		end
-		
-		it "should be fast to use timeouts" do
-			Benchmark.ips do |x|
-				x.report('Reactor#with_timeout') do |repeats|
-					Async do |task|
-						reactor = task.reactor
-						
-						repeats.times do
-							reactor.with_timeout(1) do
-							end
-						end
-					end
-				end
-				
-				x.compare!
-			end
-		end
-	end
-	
-	describe '#to_s' do
-		it "shows stopped=" do
-			expect(subject.to_s).to include "stopped"
-		end
-	end
-end

data/spec/async/semaphore_spec.rb

@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
-# 
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-# 
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-
-require 'async/semaphore'
-require 'async/barrier'
-require 'async/rspec'
-
-require_relative 'chainable_async_examples'
-
-RSpec.describe Async::Semaphore do
-	include_context Async::RSpec::Reactor
-	
-	context '#async' do
-		let(:repeats) {40}
-		let(:limit) {4}
-		
-		it 'should process work in batches' do
-			semaphore = Async::Semaphore.new(limit)
-			current, maximum = 0, 0
-			
-			result = repeats.times.map do |i|
-				semaphore.async do |task|
-					current += 1
-					maximum = [current, maximum].max
-					task.sleep(rand * 0.1)
-					current -= 1
-					
-					i
-				end
-			end.collect(&:result)
-			
-			# Verify that the maximum number of concurrent tasks was the specificed limit:
-			expect(maximum).to be == limit
-			
-			# Verify that the results were in the correct order:
-			expect(result).to be == (0...repeats).to_a
-		end
-		
-		it 'only allows one task at a time' do
-			semaphore = Async::Semaphore.new(1)
-			order = []
-			
-			3.times.map do |i|
-				semaphore.async do |task|
-					order << i
-					task.sleep(0.1)
-					order << i
-				end
-			end.collect(&:result)
-			
-			expect(order).to be == [0, 0, 1, 1, 2, 2]
-		end
-		
-		it 'allows tasks to execute concurrently' do
-			semaphore = Async::Semaphore.new(3)
-			order = []
-			
-			3.times.map do |i|
-				semaphore.async do |task|
-					order << i
-					task.sleep(0.1)
-					order << i
-				end
-			end.collect(&:result)
-			
-			expect(order).to be == [0, 1, 2, 0, 1, 2]
-		end
-	end
-	
-	context '#waiting' do
-		subject {Async::Semaphore.new(0)}
-		it 'handles exceptions thrown while waiting' do
-			expect do
-				reactor.with_timeout(0.1) do
-					subject.acquire do
-					end
-				end
-			end.to raise_error(Async::TimeoutError)
-			
-			expect(subject.waiting).to be_empty
-		end
-	end
-	
-	context '#count' do
-		it 'should count number of current acquisitions' do
-			expect(subject.count).to be == 0
-			
-			subject.acquire do
-				expect(subject.count).to be == 1
-			end
-		end
-	end
-	
-	context '#limit' do
-		it 'should have a default limit' do
-			expect(subject.limit).to be == 1
-		end
-	end
-	
-	context '#empty?' do
-		it 'should be empty unless acquired' do
-			expect(subject).to be_empty
-			
-			subject.acquire do
-				expect(subject).to_not be_empty
-			end
-		end
-	end
-	
-	context '#blocking?' do
-		it 'will be blocking when acquired' do
-			expect(subject).to_not be_blocking
-			
-			subject.acquire do
-				expect(subject).to be_blocking
-			end
-		end
-	end
-	
-	context '#acquire/#release' do
-		it 'works when called without block' do
-			subject.acquire
-			
-			expect(subject.count).to be == 1
-			
-			subject.release
-			
-			expect(subject.count).to be == 0
-		end
-	end
-	
-	context 'with barrier' do
-		let(:capacity) {2}
-		let(:barrier) {Async::Barrier.new}
-		let(:repeats) {capacity * 2}
-		
-		it 'should execute several tasks and wait using a barrier' do
-			repeats.times do
-				subject.async(parent: barrier) do |task|
-					task.sleep 0.1
-				end
-			end
-			
-			expect(barrier.size).to be == repeats
-			barrier.wait
-		end
-	end
-	
-	it_behaves_like 'chainable async'
-end