diff --git a/ext/system_timer/system_timer_native.c b/ext/system_timer/system_timer_native.c index 11246ad..f5c1842 100644 --- a/ext/system_timer/system_timer_native.c +++ b/ext/system_timer/system_timer_native.c @@ -1,9 +1,9 @@ /* * SystemTimer native implementation relying on ITIMER_REAL - * + * * Copyright 2008 David Vollbracht & Philippe Hanrigou */ - + #include "ruby.h" #include "rubysig.h" #include @@ -55,7 +55,7 @@ static VALUE install_first_timer_and_save_original_configuration(VALUE self, VAL } clear_pending_sigalrm_for_ruby_threads(); log_debug("[install_first_timer] Successfully blocked SIG_ALRM at O.S. level\n"); - + /* * Save previous signal handler. */ @@ -67,15 +67,15 @@ static VALUE install_first_timer_and_save_original_configuration(VALUE self, VAL return Qnil; } log_debug("[install_first_timer] Successfully saved existing SIG_ALRM handler\n"); - - /* - * Install Ruby Level SIG_ALRM handler - */ + + /* + * Install Ruby Level SIG_ALRM handler + */ install_ruby_sigalrm_handler(self); /* - * Save original real time interval timer and aet new real time interval timer. - */ + * Save original real time interval timer and aet new real time interval timer. + */ set_itimerval(&original_timer_interval, 0.0); set_itimerval_with_minimum_1s_interval(&timer_interval, seconds); if (0 != setitimer(ITIMER_REAL, &timer_interval, &original_timer_interval)) { @@ -96,7 +96,7 @@ static VALUE install_first_timer_and_save_original_configuration(VALUE self, VAL log_error("[install_first_timer] Could not unblock SIG_ALRM, timeout will not work", DISPLAY_ERRNO); restore_original_timer_interval(); restore_original_ruby_sigalrm_handler(self); - restore_original_sigalrm_mask_when_blocked(); + restore_original_sigalrm_mask_when_blocked(); } log_debug("[install_first_timer] Successfully unblocked SIG_ALRM.\n"); @@ -121,10 +121,10 @@ static VALUE install_next_timer(VALUE self, VALUE seconds) } clear_pending_sigalrm_for_ruby_threads(); log_debug("[install_next_timer] Successfully blocked SIG_ALRM at O.S. level\n"); - + /* * Set new real time interval timer. - */ + */ set_itimerval_with_minimum_1s_interval(&timer_interval, seconds); if (0 != setitimer(ITIMER_REAL, &timer_interval, NULL)) { log_error("[install_next_timer] Could not install our own timer, timeout will not work", DISPLAY_ERRNO); @@ -132,7 +132,7 @@ static VALUE install_next_timer(VALUE self, VALUE seconds) return Qnil; } if (debug_enabled) { - log_debug("[install_next_timer] Successfully installed timer (%ds + %dus)\n", + log_debug("[install_next_timer] Successfully installed timer (%ds + %dus)\n", timer_interval.it_value.tv_sec, timer_interval.it_value.tv_usec); } @@ -163,7 +163,7 @@ static VALUE restore_original_configuration(VALUE self) * Install Ruby Level SIG_ALRM handler */ restore_original_ruby_sigalrm_handler(self); - + if (original_signal_handler.sa_handler == NULL) { log_error("[restore_original_configuration] Previous SIG_ALRM handler not initialized!", DO_NOT_DISPLAY_ERRNO); } else if (0 == sigaction(SIGALRM, &original_signal_handler, NULL)) { @@ -172,9 +172,9 @@ static VALUE restore_original_configuration(VALUE self) log_error("[restore_original_configuration] Could not restore previous handler for SIG_ALRM", DISPLAY_ERRNO); } original_signal_handler.sa_handler = NULL; - + restore_original_timer_interval(); - restore_original_sigalrm_mask_when_blocked(); + restore_original_sigalrm_mask_when_blocked(); } /* @@ -199,7 +199,7 @@ static void restore_sigalrm_mask(sigset_t *previous_mask) log_debug("[restore_sigalrm_mask] Unblocked SIG_ALRM\n"); } else { log_debug("[restore_sigalrm_mask] No Need to unblock SIG_ALRM\n"); - } + } } static void restore_original_sigalrm_mask_when_blocked() @@ -231,19 +231,19 @@ static VALUE enable_debug(VALUE self) { static VALUE disable_debug(VALUE self) { debug_enabled = 0; - return Qnil; + return Qnil; } -static void log_debug(char* message, ...) +static void log_debug(char* message, ...) { va_list argp; - - if (0 != debug_enabled) { - va_start(argp, message); + + if (0 != debug_enabled) { + va_start(argp, message); vfprintf(stdout, message, argp); va_end(argp); } - return; + return; } static void log_error(char* message, int display_errno) @@ -277,7 +277,7 @@ static void set_itimerval_with_minimum_1s_interval(struct itimerval *value, VALUE seconds) { double sanitized_second_interval; - + sanitized_second_interval = NUM2DBL(seconds) + MINIMUM_TIMER_INTERVAL_IN_SECONDS; if (sanitized_second_interval < MINIMUM_TIMER_INTERVAL_IN_SECONDS ) { sanitized_second_interval = MINIMUM_TIMER_INTERVAL_IN_SECONDS; @@ -295,14 +295,14 @@ static void set_itimerval(struct itimerval *value, double seconds) { value->it_value.tv_usec = (long int) ((seconds - value->it_value.tv_sec) \ * MICRO_SECONDS); if (debug_enabled) { - log_debug("[set_itimerval] Set to %ds + %dus\n", value->it_value.tv_sec, + log_debug("[set_itimerval] Set to %ds + %dus\n", value->it_value.tv_sec, value->it_value.tv_usec); } return; } -void Init_system_timer_native() +void Init_system_timer_native() { init_sigalarm_mask(); rb_cSystemTimer = rb_define_module("SystemTimer"); diff --git a/lib/system_timer/concurrent_timer_pool.rb b/lib/system_timer/concurrent_timer_pool.rb index e47d5a3..e31aba9 100644 --- a/lib/system_timer/concurrent_timer_pool.rb +++ b/lib/system_timer/concurrent_timer_pool.rb @@ -1,13 +1,13 @@ # Copyright 2008 David Vollbracht & Philippe Hanrigou module SystemTimer - + class ConcurrentTimerPool - + def registered_timers @timers ||= [] end - + def register_timer(trigger_time, thread, exception_class=nil) new_timer = ThreadTimer.new(trigger_time, thread, exception_class) registered_timers << new_timer @@ -19,15 +19,15 @@ def add_timer(interval_in_seconds, exception_class=nil) log_registered_timers if SystemTimer.debug_enabled? new_timer end - + def cancel(registered_timer) registered_timers.delete registered_timer end - + def first_timer? registered_timers.size == 1 end - + def next_timer registered_timers.sort {|x,y| x.trigger_time <=> y.trigger_time}.first end @@ -41,14 +41,14 @@ def next_trigger_interval_in_seconds timer = next_timer [0, (timer.trigger_time - Time.now.to_f)].max unless timer.nil? end - + def next_expired_timer(now_in_seconds_since_epoch) candidate_timer = next_timer if SystemTimer.debug_enabled? puts "Candidate timer at #{now_in_seconds_since_epoch} : " + candidate_timer.inspect end - return nil if candidate_timer.nil? || + return nil if candidate_timer.nil? || candidate_timer.trigger_time > now_in_seconds_since_epoch candidate_timer end @@ -67,7 +67,7 @@ def trigger_next_expired_timer puts "Trigger next expired timer" if SystemTimer.debug_enabled? trigger_next_expired_timer_at Time.now.to_f end - + def log_timeout_received(thread_timer) #:nodoc: puts <<-EOS ==== Triger Timer ==== #{thread_timer} @@ -83,7 +83,7 @@ def log_registered_timers #:nodoc: Registered Timers: #{registered_timers.map {|t| t.to_s}.join("\n ")} EOS end - + end - + end diff --git a/lib/system_timer/thread_timer.rb b/lib/system_timer/thread_timer.rb index 54052fe..d83c1d7 100644 --- a/lib/system_timer/thread_timer.rb +++ b/lib/system_timer/thread_timer.rb @@ -2,21 +2,21 @@ module SystemTimer - # Timer saving associated thread. This is needed because we trigger timers - # from a Ruby signal handler and Ruby signals are always delivered to + # Timer saving associated thread. This is needed because we trigger timers + # from a Ruby signal handler and Ruby signals are always delivered to # main thread. class ThreadTimer attr_reader :trigger_time, :thread, :exception_class - + def initialize(trigger_time, thread, exception_class = nil) @trigger_time = trigger_time @thread = thread - @exception_class = exception_class || Timeout::Error + @exception_class = exception_class || Timeout::Error end - + def to_s " #{trigger_time}, :thread => #{thread}, :exception_class => #{exception_class}>" end - + end end diff --git a/lib/system_timer_stub.rb b/lib/system_timer_stub.rb index fd48962..a1a2d69 100644 --- a/lib/system_timer_stub.rb +++ b/lib/system_timer_stub.rb @@ -2,7 +2,7 @@ require 'timeout' -module SystemTimer +module SystemTimer class << self def timeout_after(seconds) @@ -12,8 +12,8 @@ def timeout_after(seconds) end # Backward compatibility with timeout.rb - alias timeout timeout_after - + alias timeout timeout_after + end - + end diff --git a/test/system_timer/concurrent_timer_pool_unit_test.rb b/test/system_timer/concurrent_timer_pool_unit_test.rb index 88bff67..669dd60 100644 --- a/test/system_timer/concurrent_timer_pool_unit_test.rb +++ b/test/system_timer/concurrent_timer_pool_unit_test.rb @@ -1,21 +1,21 @@ require File.dirname(__FILE__) + '/../test_helper' unit_tests do - + test "registered_timers is empty when there is no registered timers" do assert_equal [], SystemTimer::ConcurrentTimerPool.new.registered_timers end test "a new timer is added to the registered timer list when you register a timer" do pool = SystemTimer::ConcurrentTimerPool.new - pool.register_timer :a_trigger_time, :a_thread - assert_equal [[:a_trigger_time, :a_thread]], + pool.register_timer :a_trigger_time, :a_thread + assert_equal [[:a_trigger_time, :a_thread]], pool.registered_timers.collect {|t| [t.trigger_time, t.thread] } end test "register_timer returns the timer that was just added to the pool" do pool = SystemTimer::ConcurrentTimerPool.new - timer = pool.register_timer :a_trigger_time, :a_thread + timer = pool.register_timer :a_trigger_time, :a_thread assert_equal [:a_trigger_time, :a_thread], [timer.trigger_time, timer.thread] end @@ -24,7 +24,7 @@ Thread.stubs(:current).returns(:the_current_thread) now = Time.now Time.stubs(:now).returns(now) - + pool.expects(:register_timer).with(now.to_f + 15, :the_current_thread, nil) pool.add_timer 15 end @@ -38,7 +38,7 @@ test "cancel does not complain when timer is cancelled " + "(useful for ensure blocks)" do - + pool = SystemTimer::ConcurrentTimerPool.new a_timer = pool.add_timer 123 another_timer = pool.add_timer 456 @@ -46,7 +46,7 @@ pool.cancel(another_timer) assert_equal [a_timer], pool.registered_timers end - + test "first_timer? returns false when there is no timer" do assert_equal false, SystemTimer::ConcurrentTimerPool.new.first_timer? end @@ -71,7 +71,7 @@ pool.cancel first_timer assert_equal true, pool.first_timer? end - + test "next expired timer return nil when there is no registered timer" do assert_nil SystemTimer::ConcurrentTimerPool.new.next_expired_timer(24) end @@ -82,7 +82,7 @@ test "next_timer returns the registered timer when " + "there is only one registered timer" do - + pool = SystemTimer::ConcurrentTimerPool.new the_timer = pool.register_timer 24, stub_everything assert_equal the_timer, pool.next_timer @@ -90,7 +90,7 @@ test "next_timer returns the trigger time of the first timer to" + "expire when there is more than one registered timer" do - + pool = SystemTimer::ConcurrentTimerPool.new late_timer = pool.register_timer 64, stub_everything early_timer = pool.register_timer 24, stub_everything @@ -105,7 +105,7 @@ test "next_trigger_time returns trigger time of next timer when " + "next timer is not nil" do - + pool = SystemTimer::ConcurrentTimerPool.new the_timer = SystemTimer::ThreadTimer.new 24, stub_everything pool.expects(:next_timer).returns(the_timer) @@ -148,26 +148,26 @@ test "next_expired_timer returns the timer that was trigerred" + "when a timer has expired" do - + pool = SystemTimer::ConcurrentTimerPool.new the_timer = pool.register_timer 24, :a_thread assert_equal the_timer, pool.next_expired_timer(24) - end + end test "next_expired_timer returns nil when no timer has expired yet" do pool = SystemTimer::ConcurrentTimerPool.new pool.register_timer 24, :a_thread assert_nil pool.next_expired_timer(23) - end + end test "next_expired_timer returns the timer that first expired " + "when there is more than one expired timer" do - + pool = SystemTimer::ConcurrentTimerPool.new last_to_expire = pool.register_timer 64, :a_thread first_to_expire = pool.register_timer 24, :a_thread assert_equal first_to_expire, pool.next_expired_timer(100) - end + end test "trigger_next_expired_timer_at does not raise when there is no registered timer" do SystemTimer::ConcurrentTimerPool.new.trigger_next_expired_timer_at 1234 @@ -175,10 +175,10 @@ test "trigger_next_expired_timer_at raises a TimeoutError in the context of " + "its thread when there is a registered timer that has expired" do - + pool = SystemTimer::ConcurrentTimerPool.new the_thread = mock('thread') - + Timeout::Error.expects(:new).with("time's up!").returns(:the_exception) the_thread.expects(:raise).with(:the_exception) pool.register_timer 24, the_thread @@ -201,7 +201,7 @@ test "trigger_next_expired_timer_at triggers the first registered timer that " + "expired whatever the timer insertion order is" do - + pool = SystemTimer::ConcurrentTimerPool.new second_to_expire = pool.register_timer 64, stub_everything first_to_expire = pool.register_timer 24, stub_everything @@ -211,7 +211,7 @@ test "trigger_next_expired_timer_at remove the expired timer from the pool" do pool = SystemTimer::ConcurrentTimerPool.new - pool.register_timer 24, stub_everything + pool.register_timer 24, stub_everything pool.trigger_next_expired_timer_at 24 end @@ -226,7 +226,7 @@ pool = SystemTimer::ConcurrentTimerPool.new the_timer = pool.register_timer 24, stub_everything SystemTimer.stubs(:debug_enabled?).returns(true) - + pool.expects(:log_timeout_received).with(the_timer) pool.trigger_next_expired_timer_at 24 ensure @@ -236,7 +236,7 @@ test "trigger_next_expired_timer_at does not logs timeoout when SystemTimer " + "debug mode is disabled " do - + pool = SystemTimer::ConcurrentTimerPool.new the_timer = pool.register_timer 24, stub_everything SystemTimer.stubs(:debug_enabled?).returns(false) @@ -252,7 +252,7 @@ begin stdout = StringIO.new $stdout = stdout - + pool = SystemTimer::ConcurrentTimerPool.new the_timer = pool.register_timer 24, stub_everything SystemTimer.stubs(:debug_enabled?).returns(true) @@ -263,29 +263,29 @@ $stdout = original_stdout end end - + test "trigger_next_expired_timer is a shorcut method calling " + "trigger_next_expired_timer_at with current epoch time" do - + now = Time.now pool = SystemTimer::ConcurrentTimerPool.new Time.stubs(:now).returns(now) - + pool.expects(:trigger_next_expired_timer_at).with(now.to_f) pool.trigger_next_expired_timer end - + test "log_timeout_received does not raise" do original_stdout = $stdout begin stdout = StringIO.new $stdout = stdout - + SystemTimer::ConcurrentTimerPool.new.log_timeout_received(SystemTimer::ThreadTimer.new(:a_time, :a_thread)) assert_match %r{==== Triger Timer ====}, stdout.string ensure $stdout = original_stdout end end - + end diff --git a/test/system_timer_functional_test.rb b/test/system_timer_functional_test.rb index 0d7d878..9ef7385 100644 --- a/test/system_timer_functional_test.rb +++ b/test/system_timer_functional_test.rb @@ -1,50 +1,50 @@ require File.dirname(__FILE__) + '/test_helper' functional_tests do - + DEFAULT_ERROR_MARGIN = 2 test "original_ruby_sigalrm_handler is nil after reset" do SystemTimer.send(:install_ruby_sigalrm_handler) SystemTimer.send(:reset_original_ruby_sigalrm_handler) assert_nil SystemTimer.send(:original_ruby_sigalrm_handler) - end - + end + test "original_ruby_sigalrm_handler is set to existing handler after " + "install_ruby_sigalrm_handler when save_previous_handler is true" do SystemTimer.expects(:trap).with('SIGALRM').returns(:an_existing_handler) SystemTimer.send(:install_ruby_sigalrm_handler) assert_equal :an_existing_handler, SystemTimer.send(:original_ruby_sigalrm_handler) end - + test "restore_original_ruby_sigalrm_handler traps sigalrm using original_ruby_sigalrm_handler" do SystemTimer.stubs(:original_ruby_sigalrm_handler).returns(:the_original_handler) SystemTimer.expects(:trap).with('SIGALRM', :the_original_handler) SystemTimer.send :restore_original_ruby_sigalrm_handler - end - + end + test "restore_original_ruby_sigalrm_handler resets original_ruby_sigalrm_handler" do SystemTimer.stubs(:trap) SystemTimer.expects(:reset_original_ruby_sigalrm_handler) SystemTimer.send :restore_original_ruby_sigalrm_handler - end - + end + test "restore_original_ruby_sigalrm_handler reset SIGALRM handler to default when original_ruby_sigalrm_handler is nil" do SystemTimer.stubs(:original_ruby_sigalrm_handler) SystemTimer.expects(:trap).with('SIGALRM', 'DEFAULT') SystemTimer.stubs(:reset_original_ruby_sigalrm_handler) SystemTimer.send :restore_original_ruby_sigalrm_handler - end - + end + test "restore_original_ruby_sigalrm_handler resets original_ruby_sigalrm_handler when trap raises" do SystemTimer.stubs(:trap).returns(:the_original_handler) SystemTimer.send(:install_ruby_sigalrm_handler) SystemTimer.expects(:trap).raises("next time maybe...") SystemTimer.expects(:reset_original_ruby_sigalrm_handler) - + SystemTimer.send(:restore_original_ruby_sigalrm_handler) rescue nil - end - + end + test "timeout_after raises TimeoutError if block takes too long" do assert_raises(Timeout::Error) do SystemTimer.timeout_after(1) {sleep 5} @@ -64,18 +64,18 @@ SystemTimer.timeout_after(1, ACustomException) {sleep 5} end end - + test "timeout_after does not raises Timeout Error if block completes in time" do SystemTimer.timeout_after(5) {sleep 1} end - + test "timeout_after returns the value returned by the black" do assert_equal :block_value, SystemTimer.timeout_after(1) {:block_value} end - + test "timeout_after raises TimeoutError in thread that called timeout_after" do raised_thread = nil - other_thread = Thread.new do + other_thread = Thread.new do begin SystemTimer.timeout_after(1) {sleep 5} flunk "Should have timed out" @@ -83,23 +83,23 @@ raised_thread = Thread.current end end - - other_thread.join + + other_thread.join assert_equal other_thread, raised_thread end - + test "cancelling a timer that was installed restores previous ruby handler for SIG_ALRM" do begin fake_original_ruby_handler = proc {} initial_ruby_handler = trap "SIGALRM", fake_original_ruby_handler SystemTimer.install_first_timer_and_save_original_configuration 3 SystemTimer.restore_original_configuration - assert_equal fake_original_ruby_handler, trap("SIGALRM", "IGNORE") + assert_equal fake_original_ruby_handler, trap("SIGALRM", "IGNORE") ensure # avoid interfering with test infrastructure - trap("SIGALRM", initial_ruby_handler) if initial_ruby_handler + trap("SIGALRM", initial_ruby_handler) if initial_ruby_handler end end - + test "debug_enabled returns true after enabling debug" do begin SystemTimer.disable_debug @@ -108,8 +108,8 @@ ensure SystemTimer.disable_debug end - end - + end + test "debug_enabled returns false after disable debug" do begin SystemTimer.enable_debug @@ -117,9 +117,9 @@ assert_equal false, SystemTimer.debug_enabled? ensure SystemTimer.disable_debug - end + end end - + test "timeout offers an API fully compatible with timeout.rb" do assert_raises(Timeout::Error) do SystemTimer.timeout(1) {sleep 5} @@ -132,7 +132,7 @@ # quickly as we should. Needs further investigation. At least the # SIGALRM ensures that the system will schedule M.R.I. native thread. # - # + # # test "while exact timeouts cannot be guaranted the timeout should not exceed the provided timeout by 2 seconds" do # start = Time.now # begin @@ -146,8 +146,8 @@ # elapsed = Time.now - start # assert elapsed < 4, "Got #{elapsed} s, expected 2, at most 4" # end - - + + test "timeout are enforced on system calls" do assert_timeout_within(3) do SystemTimer.timeout(3) do @@ -155,7 +155,7 @@ end end end - + test "timeout work when spawning a different thread" do assert_timeout_within(3) do thread = Thread.new do @@ -166,7 +166,7 @@ thread.join end end - + test "can set multiple serial timers" do 10.times do |i| print(i) & STDOUT.flush @@ -188,7 +188,7 @@ end end end - + test "timeout work when setting concurrent timers, the first one expiring before the second one" do first_thread = Thread.new do assert_timeout_within(3) do @@ -207,7 +207,7 @@ first_thread.join second_thread.join end - + test "timeout work when setting concurrent timers, the second one expiring before the first one" do first_thread = Thread.new do @@ -227,9 +227,9 @@ first_thread.join second_thread.join end - + test "timeout work when setting concurrent timers with the exact same timeout" do - + first_thread = Thread.new do assert_timeout_within(2) do SystemTimer.timeout(2) do @@ -250,7 +250,7 @@ test "timeout works with random concurrent timers dynamics" do all_threads = [] - + 10.times do a_timeout = [1, (rand(10)).to_f].max all_threads << Thread.new do @@ -261,22 +261,22 @@ end end end - + all_threads.each {|t| t.join} end - - def assert_timeout_within(expected_timeout_in_seconds, - error_margin = DEFAULT_ERROR_MARGIN, - &block) - start = Time.now + + def assert_timeout_within(expected_timeout_in_seconds, + error_margin = DEFAULT_ERROR_MARGIN, + &block) + start = Time.now yield flunk "Did not timeout as expected!" - rescue Timeout::Error + rescue Timeout::Error elapsed = Time.now - start - assert elapsed >= expected_timeout_in_seconds, + assert elapsed >= expected_timeout_in_seconds, "Timed out too early, expected #{expected_timeout_in_seconds}, got #{elapsed} s" - assert elapsed < (expected_timeout_in_seconds + error_margin), + assert elapsed < (expected_timeout_in_seconds + error_margin), "Timed out after #{elapsed} seconds, expected #{expected_timeout_in_seconds}" end - + end diff --git a/test/system_timer_unit_test.rb b/test/system_timer_unit_test.rb index cc27a79..ded11fa 100644 --- a/test/system_timer_unit_test.rb +++ b/test/system_timer_unit_test.rb @@ -1,7 +1,7 @@ require File.dirname(__FILE__) + '/test_helper' unit_tests do - + test "timeout_after registers a new timer in the timer pool" do pool = stub_everything Thread.stubs(:current).returns(:the_current_thread) @@ -10,7 +10,7 @@ SystemTimer.stubs(:restore_original_configuration) pool.expects(:add_timer).with(5, nil).returns(stub_everything) - SystemTimer.timeout_after(5) {} + SystemTimer.timeout_after(5) {} end test "timeout_after registers a new timer with a custom timeout exception in the timer pool" do @@ -22,23 +22,23 @@ SystemTimer.stubs(:restore_original_configuration) pool.expects(:add_timer).with(5, MyCustomException).returns(stub_everything) - SystemTimer.timeout_after(5, MyCustomException) {} + SystemTimer.timeout_after(5, MyCustomException) {} end test "timeout_after installs a system timer saving the previous " + "configuration when there is only one timer" do - + now = Time.now Time.stubs(:now).returns(now) SystemTimer.stubs(:restore_original_configuration) SystemTimer.expects(:install_first_timer_and_save_original_configuration) \ .with {|value| value.between?(23.99, 24.01) } - SystemTimer.timeout_after(24) {} + SystemTimer.timeout_after(24) {} end test "timeout_after installs a system timer without saving the previous " + "configuration when there is more than one timer" do - + now = Time.now Time.stubs(:now).returns(now) SystemTimer.timer_pool.register_timer now.to_f + 100, :a_thread @@ -47,12 +47,12 @@ SystemTimer.expects(:install_next_timer) \ .with {|value| value.between?(23.99, 24.01) } - SystemTimer.timeout_after(24) {} + SystemTimer.timeout_after(24) {} end test "timeout_after installs a system timer with the interval before " + "the next timer to expire" do - + now = Time.now Time.stubs(:now).returns(now) SystemTimer.timer_pool.register_timer now.to_f + 24, :a_thread @@ -61,22 +61,22 @@ SystemTimer.expects(:install_next_timer) \ .with {|value| value.between?(23.99, 24.01) } - SystemTimer.timeout_after(100) {} + SystemTimer.timeout_after(100) {} end - + test "timeout_after cancels the timer when the block completes without " + "timeout" do - + now = Time.now the_timer = stub_everything Time.stubs(:now).returns(now) SystemTimer.stubs(:restore_original_configuration) - SystemTimer.stubs(:install_first_timer_and_save_original_configuration) + SystemTimer.stubs(:install_first_timer_and_save_original_configuration) SystemTimer.timer_pool.stubs(:add_timer).returns(the_timer) SystemTimer.timer_pool.stubs(:first_timer?).returns(true) - + SystemTimer.timer_pool.expects(:cancel).with(the_timer) - SystemTimer.timeout_after(24) {} + SystemTimer.timeout_after(24) {} end test "debug does not output to stdout when debug is disabled" do @@ -85,12 +85,12 @@ begin stdout = StringIO.new $stdout = stdout - + SystemTimer.send :debug, "a log message" assert stdout.string.empty? ensure $stdout = original_stdout - end + end end test "debug logs messaget to stdout when debug is enabled" do @@ -99,12 +99,12 @@ begin stdout = StringIO.new $stdout = stdout - + SystemTimer.send :debug, "a log message" assert_match /a log message/, stdout.string ensure $stdout = original_stdout - end + end end end