timers 4.1.1 → 4.3.1

data/spec/events_spec.rb

@@ -1,57 +0,0 @@
-
-require 'spec_helper'
-
-RSpec.describe Timers::Events do
-  it "should register an event" do
-    fired = false
-    
-    callback = proc do |time|
-      fired = true
-    end
-    
-    subject.schedule(0.1, callback)
-    
-    expect(subject.size).to be == 1
-    
-    subject.fire(0.15)
-    
-    expect(subject.size).to be == 0
-    
-    expect(fired).to be true
-  end
-  
-  it "should register events in order" do
-    fired = []
-    
-    times = [0.95, 0.1, 0.3, 0.5, 0.4, 0.2, 0.01, 0.9]
-    
-    times.each do |requested_time|
-      callback = proc do |time|
-        fired << requested_time
-      end
-      
-      subject.schedule(requested_time, callback)
-    end
-    
-    subject.fire(0.5)
-    expect(fired).to be == times.sort.first(6)
-    
-    subject.fire(1.0)
-    expect(fired).to be == times.sort
-  end
-  
-  it "should fire events with the time they were fired at" do
-    fired_at = :not_fired
-    
-    callback = proc do |time|
-      # The time we actually were fired at:
-      fired_at = time
-    end
-    
-    subject.schedule(0.5, callback)
-    
-    subject.fire(1.0)
-    
-    expect(fired_at).to be == 1.0
-  end
-end

data/spec/every_spec.rb

@@ -1,34 +0,0 @@
-
-require 'spec_helper'
-
-RSpec.describe Timers::Group do
-  it "should fire several times" do
-    result = []
-
-    subject.every(0.7) { result << :a }
-    subject.every(2.3) { result << :b }
-    subject.every(1.3) { result << :c }
-    subject.every(2.4) { result << :d }
-
-    Timers::Wait.for(2.5) do |remaining|
-      subject.wait if subject.wait_interval < remaining
-    end
-
-    expect(result).to be == [:a, :c, :a, :a, :b, :d]
-  end
-
-  it "should fire immediately and then several times later" do
-    result = []
-
-    subject.every(0.7) { result << :a }
-    subject.every(2.3) { result << :b }
-    subject.now_and_every(1.3) { result << :c }
-    subject.now_and_every(2.4) { result << :d }
-
-    Timers::Wait.for(2.5) do |remaining|
-      subject.wait if subject.wait_interval < remaining
-    end
-
-    expect(result).to be == [:c, :d, :a, :c, :a, :a, :b, :d]
-  end
-end

data/spec/group_spec.rb

@@ -1,254 +0,0 @@
-
-require 'spec_helper'
-
-RSpec.describe Timers::Group do
-  describe "#wait" do
-    it "calls the wait block with nil" do
-      called = false
-      
-      subject.wait do |interval|
-        expect(interval).to be == nil
-        called = true
-      end
-      
-      expect(called).to be true
-    end
-  
-    it "calls the wait block with an interval" do
-      called = false
-      fired = false
-
-      subject.after(0.1) { fired = true }
-
-      subject.wait do |interval|
-        expect(interval).to be_within(TIMER_QUANTUM).of(0.1)
-        called = true
-        sleep 0.2
-      end
-
-      expect(called).to be true
-      expect(fired).to be true
-    end
-  end
-  
-  it "sleeps until the next timer" do
-    interval   = TIMER_QUANTUM * 2
-    started_at = Time.now
-
-    fired = false
-    subject.after(interval) { fired = true }
-    subject.wait
-
-    expect(fired).to be true
-    expect(Time.now - started_at).to be_within(TIMER_QUANTUM).of interval
-  end
-
-  it "fires instantly when next timer is in the past" do
-    fired = false
-    subject.after(TIMER_QUANTUM) { fired = true }
-    sleep(TIMER_QUANTUM * 2)
-    subject.wait
-
-    expect(fired).to be true
-  end
-
-  it "calculates the interval until the next timer should fire" do
-    interval = 0.1
-
-    subject.after(interval)
-    expect(subject.wait_interval).to be_within(TIMER_QUANTUM).of interval
-
-    sleep(interval)
-    expect(subject.wait_interval).to be <= 0
-  end
-
-  it "fires timers in the correct order" do
-    result = []
-
-    subject.after(TIMER_QUANTUM * 2) { result << :two }
-    subject.after(TIMER_QUANTUM * 3) { result << :three }
-    subject.after(TIMER_QUANTUM * 1) { result << :one }
-
-    sleep TIMER_QUANTUM * 4
-    subject.fire
-
-    expect(result).to eq [:one, :two, :three]
-  end
-
-  it "raises TypeError if given an invalid time" do
-    expect do
-      subject.after(nil) { nil }
-    end.to raise_exception(TypeError)
-  end
-
-  describe "recurring timers" do
-    it "continues to fire the timers at each interval" do
-      result = []
-
-      subject.every(TIMER_QUANTUM * 2) { result << :foo }
-
-      sleep TIMER_QUANTUM * 3
-      subject.fire
-      expect(result).to eq [:foo]
-
-      sleep TIMER_QUANTUM * 5
-      subject.fire
-      expect(result).to eq [:foo, :foo]
-    end
-  end
-
-  it "calculates the proper interval to wait until firing" do
-    interval_ms = 25
-
-    subject.after(interval_ms / 1000.0)
-
-    expect(subject.wait_interval).to be_within(TIMER_QUANTUM).of(interval_ms / 1000.0)
-  end
-
-  describe "pause and continue timers" do
-    before(:each) do
-      @interval   = TIMER_QUANTUM * 2
-
-      @fired = false
-      @timer = subject.after(@interval) { @fired = true }
-      @fired2 = false
-      @timer2 = subject.after(@interval) { @fired2 = true }
-    end
-
-    it "does not fire when paused" do
-      @timer.pause
-      subject.wait
-      expect(@fired).to be false
-    end
-
-    it "fires when continued after pause" do
-      @timer.pause
-      subject.wait
-      @timer.resume
-      
-      sleep @timer.interval
-      subject.wait
-      
-      expect(@fired).to be true
-    end
-
-    it "can pause all timers at once" do
-      subject.pause
-      subject.wait
-      expect(@fired).to be false
-      expect(@fired2).to be false
-    end
-
-    it "can continue all timers at once" do
-      subject.pause
-      subject.wait
-      subject.resume
-      
-      # We need to wait until we are sure both timers will fire, otherwise highly accurate clocks (e.g. JVM) may only fire the first timer, but not the second, because they are actually schedueled at different times.
-      sleep TIMER_QUANTUM * 2
-      subject.wait
-      
-      expect(@fired).to be true
-      expect(@fired2).to be true
-    end
-
-    it "can fire the timer directly" do
-      fired = false
-      timer = subject.after( TIMER_QUANTUM * 1 ) { fired = true }
-      timer.pause
-      subject.wait
-      expect(fired).not_to be true
-      timer.resume
-      expect(fired).not_to be true
-      timer.fire
-      expect(fired).to be true
-    end
-
-  end
-
-  describe "delay timer" do
-    it "adds appropriate amount of time to timer" do
-      timer = subject.after(10)
-      timer.delay(5)
-      expect(timer.offset - subject.current_offset).to be_within(TIMER_QUANTUM).of(15)
-    end
-  end
-
-  describe "delay timer collection" do
-    it "delay on set adds appropriate amount of time to all timers" do
-      timer = subject.after(10)
-      timer2 = subject.after(20)
-      subject.delay(5)
-      expect(timer.offset - subject.current_offset).to be_within(TIMER_QUANTUM).of(15)
-      expect(timer2.offset - subject.current_offset).to be_within(TIMER_QUANTUM).of(25)
-    end
-  end
-
-  describe "on delaying a timer" do
-    it "fires timers in the correct order" do
-      result = []
-
-      subject.after(TIMER_QUANTUM * 2) { result << :two }
-      subject.after(TIMER_QUANTUM * 3) { result << :three }
-      first = subject.after(TIMER_QUANTUM * 1) { result << :one }
-      first.delay(TIMER_QUANTUM * 3)
-
-      sleep TIMER_QUANTUM * 5
-      subject.fire
-
-      expect(result).to eq [:two, :three, :one]
-    end
-  end
-
-  describe "Timer inspection" do
-    it "before firing" do
-      fired = false
-      timer = subject.after(TIMER_QUANTUM * 5) { fired = true }
-      timer.pause
-      expect(fired).not_to be true
-      expect(timer.inspect).to match(/\A#<Timers::Timer:[\da-f]+ fires in [-\.\de]+ seconds>\Z/)
-    end
-
-    it "after firing" do
-      fired = false
-      timer = subject.after(TIMER_QUANTUM) { fired = true }
-
-      subject.wait
-
-      expect(fired).to be true
-      expect(timer.inspect).to match(/\A#<Timers::Timer:[\da-f]+ fired [-\.\de]+ seconds ago>\Z/)
-    end
-
-    it "recurring firing" do
-      result = []
-      timer = subject.every(TIMER_QUANTUM) { result << :foo }
-
-      subject.wait
-      expect(result).not_to be_empty
-      expect(timer.inspect).to match(/\A#<Timers::Timer:[\da-f]+ fires in [-\.\de]+ seconds, recurs every #{sprintf("%0.2f", TIMER_QUANTUM)}>\Z/)
-    end
-  end
-
-  describe "fires_in" do
-    let(:interval) { TIMER_QUANTUM * 2 }
-
-    it "calculates the interval until the next fire if it's recurring" do
-      timer = subject.every(interval) { true }
-      expect(timer.fires_in).to be_within(TIMER_QUANTUM).of(interval)
-    end
-
-    context "when timer is not recurring" do
-      let!(:timer) { subject.after(interval) { true } }
-
-      it "calculates the interval until the next fire if it hasn't already fired" do
-        expect(timer.fires_in).to be_within(TIMER_QUANTUM).of(interval)
-      end
-
-      it "calculates the interval since last fire if already fired" do
-        subject.wait
-        sleep(interval)
-        expect(timer.fires_in).to be_within(TIMER_QUANTUM).of(0 - interval)
-      end
-    end
-  end
-end

data/spec/performance_spec.rb

@@ -1,100 +0,0 @@
-require 'spec_helper'
-
-# Event based timers:
-
-# Serviced 31812 events in 2.39075272 seconds, 13306.320832794887 e/s.
-# Thread ID: 7336700
-# Fiber ID: 30106340
-# Total: 2.384043
-# Sort by: self_time
-
-# %self      total      self      wait     child     calls  name
-# 13.48      0.510     0.321     0.000     0.189    369133  Timers::Events::Handle#<=>
-#  8.12      0.194     0.194     0.000     0.000    427278  Timers::Events::Handle#to_f
-#  4.55      0.109     0.109     0.000     0.000    427278  Float#<=>
-#  4.40      1.857     0.105     0.000     1.752    466376 *Timers::Events#bsearch
-#  4.30      0.103     0.103     0.000     0.000    402945  Float#to_f
-#  2.65      0.063     0.063     0.000     0.000     33812  Array#insert
-#  2.64      1.850     0.063     0.000     1.787     33812  Timers::Events#schedule
-#  2.40      1.930     0.057     0.000     1.873     33812  Timers::Timer#reset
-#  1.89      1.894     0.045     0.000     1.849     31812  Timers::Timer#fire
-#  1.69      1.966     0.040     0.000     1.926     31812  Timers::Events::Handle#fire
-#  1.35      0.040     0.032     0.000     0.008     33812  Timers::Events::Handle#initialize
-#  1.29      0.044     0.031     0.000     0.013     44451  Timers::Group#current_offset
-
-# SortedSet based timers:
-
-# Serviced 32516 events in 66.753277275 seconds, 487.1072288781219 e/s.
-# Thread ID: 15995640
-# Fiber ID: 38731780
-# Total: 66.716394
-# Sort by: self_time
-
-# %self      total      self      wait     child     calls  name
-# 54.73     49.718    36.513     0.000    13.205  57084873  Timers::Timer#<=>
-# 23.74     65.559    15.841     0.000    49.718     32534  Array#sort!
-# 19.79     13.205    13.205     0.000     0.000  57084873  Float#<=>
-
-# Max out events performance (on my computer):
-# Serviced 1142649 events in 11.194903921 seconds, 102068.70405115146 e/s.
-
-RSpec.describe Timers::Group do
-
-  it "runs efficiently" do
-    result = []
-    range = (1..500)
-    duration = 2.0
-
-    total = 0
-    range.each do |index|
-      offset = index.to_f / range.max
-      total += (duration / offset).floor
-      
-      subject.every(index.to_f / range.max, :strict) { result << index }
-    end
-    
-    subject.wait while result.size < total
-    
-    rate = result.size.to_f / subject.current_offset
-    puts "Serviced #{result.size} events in #{subject.current_offset} seconds, #{rate} e/s."
-    
-    expect(subject.current_offset).to be_within(TIMER_QUANTUM).of(duration)
-  end
-
-=begin
-  it "runs efficiently at high volume" do
-    results = []
-    range = (1..300)
-    groups = (1..20)
-    duration = 101
-
-    timers = []
-    @mutex = Mutex.new
-    start = Time.now
-    groups.each do |gi|
-      timers << Thread.new {
-        result = []
-        timer = Timers::Group.new
-        total = 0
-        range.each do |ri|
-          offset = ri.to_f / range.max
-          total += (duration / offset).floor
-          timer.every(ri.to_f / range.max, :strict) { result << ri }
-        end
-        timer.wait while result.size < total
-        @mutex.synchronize { results += result }
-        
-      }
-    end
-    timers.each { |t| t.join }
-    finish = Time.now
-    
-    rate = results.size.to_f / ( runtime = finish - start )
-    
-    puts "Serviced #{results.size} events in #{runtime} seconds, #{rate} e/s; across #{groups.max} timers."
-    
-    expect(runtime).to be_within(TIMER_QUANTUM).of(duration)
-  end
-=end
-
-end

data/spec/spec_helper.rb

@@ -1,19 +0,0 @@
-require 'coveralls'
-Coveralls.wear!
-
-require 'bundler/setup'
-require 'timers'
-
-# Level of accuracy enforced by tests (50ms)
-TIMER_QUANTUM = 0.05
-
-RSpec.configure do |config|
-  # Setting this config option `false` removes rspec-core's monkey patching of the
-  # top level methods like `describe`, `shared_examples_for` and `shared_context`
-  # on `main` and `Module`. The methods are always available through the `RSpec`
-  # module like `RSpec.describe` regardless of this setting.
-  # For backwards compatibility this defaults to `true`.
-  #
-  # https://relishapp.com/rspec/rspec-core/v/3-0/docs/configuration/global-namespace-dsl
-  config.expose_dsl_globally = false
-end