From: Rob Biedenharn <Rob@...>
Date: 2006-11-30T02:24:17+09:00
Subject: Why doesn't Timeout work with String#=~

--Apple-Mail-38--317248553
Content-Transfer-Encoding: 7bit
Content-Type: text/plain;
	charset=US-ASCII;
	delsp=yes;
	format=flowed

Sorry for the length, but I hope that will a running test case,  
someone can explain this one.  I'm running this on Mac OS X 10.4.8  
and with ruby 1.8.4

Apple's ruby is still present, but shouldn't be used
rab:ruby $ whereis ruby
/usr/bin/ruby
rab:ruby $ /usr/bin/ruby -v
ruby 1.8.2 (2004-12-25) [universal-darwin8.0]

rab:ruby $ which ruby
/usr/local/bin/ruby
rab:ruby $ ruby -v
ruby 1.8.4 (2005-12-24) [i686-darwin8.5.2]
rab:ruby $ /usr/bin/env ruby -v
ruby 1.8.4 (2005-12-24) [i686-darwin8.5.2]

rab:ruby $ uname -mrsv
Darwin 8.8.1 Darwin Kernel Version 8.8.1: Mon Sep 25 19:42:00 PDT  
2006; root:xnu-792.13.8.obj~1/RELEASE_I386 i386

The rest of the email should be runnable as a test case to show the  
problem.  Disable the test_the_bad_regexp or uncomment the sleep  
within it to run without any intervention.

The comments in the test case tell the rest of the story...

-Rob

#!/usr/bin/env ruby -w
#
# I ran into trouble running a test on the result of a spell-checking  
action
# with a combination of a poorly formed regular expression and having  
a third
# misspelled word in the test phrase.  It was taking a LONG time (not
# completed overnight!) so I thought I'd put a timeout around the  
call so even
# a truly gastly expression would be halted after some reasonalbe  
amount of
# time.
#
# However, it appears that the regular expression match with =~  
doesn't get
# interrupted by the timeout.  Is this expected?  I found a thread about
# timeout and syscalls
# (http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/ 
178726) that
# says that syscalls are interrupted which seems to imply that things  
like
# String#=~ ought to timeout also.
#
# Here's a "minimal" test that pulls the actual response out (so I  
don't have
# to try and recreate a string that will cause the regexp to churn for a
# long while).

require 'test/unit'
require 'timeout'

class TimeoutRegexpTest < Test::Unit::TestCase
   include Timeout

   def setup
     # Note that this actually has three: 1) prhase       => phrase
     #                                    2) twoo         => two
     #                                    3) incorrectlly => incorrectly
     # so the regexp (which expects only 1 and 2) doesn't match...
     @phrase = "This prhase has only twoo incorrectlly spelled words."
     @result = <<RESULT
This <span id='wrongword_1'>prhase</span><ul  
id='wrongword_1'><li>praise</li>
<li>prose</li>\n<li>prates</li>\n<li>Pres</li>\n<li>praises</li> 
\n<li>pres</li>
<li>paras</li>\n<li>prays</li>\n<li>prams</li>\n<li>prats</li> 
\n<li>preses</li>
<li>proses</li>\n<li>Prissie</li>\n<li>presser</li>\n<li>pressie</li>
<li>presses</li>\n<li>pries</li>\n<li>peruse</li>\n<li>press</li>
<li>prance</li>\n<li>Pr's</li>\n<li>Pris</li>\n<li>pros</li> 
\n<li>pariahs</li>
<li>prices</li>\n<li>prides</li>\n<li>primes</li>\n<li>prizes</li>
<li>probes</li>\n<li>proles</li>\n<li>protease</li>\n<li>proves</li>
<li>prudes</li>\n<li>prunes</li>\n<li>parades</li>\n<li>pirates</li>
<li>prissy</li>\n<li>precise</li>\n<li>preface</li>\n<li>preheats</li>
<li>premise</li>\n<li>profuse</li>\n<li>promise</li>\n<li>propose</li>
<li>rehearse</li>\n<li>pares</li>\n<li>peres</li>\n<li>pores</li>
<li>pyres</li>\n<li>Price</li>\n<li>Pru's</li>\n<li>Pryce</li> 
\n<li>preys</li>
<li>price</li>\n<li>prize</li>\n<li>prosy</li>\n<li>prows</li> 
\n<li>para's</li>
<li>preps</li>\n<li>prigs</li>\n<li>prods</li>\n<li>profs</li> 
\n<li>proms</li>
<li>props</li>\n<li>piranhas</li>\n<li>purees</li>\n<li>Prensa</li>
<li>Ypres</li>\n<li>praise's</li>\n<li>pram's</li>\n<li>prat's</li>
<li>Peria's</li>\n<li>Prince</li>\n<li>prince</li>\n<li>pros's</li>
<li>prig's</li>\n<li>Priam's</li>\n<li>pariah's</li>\n<li>prose's</li>
<li>Prue's</li>\n<li>prey's</li>\n<li>prow's</li>\n<li>pyre's</li>
<li>Pren's</li>\n<li>Prut's</li>\n<li>prep's</li>\n<li>prof's</li>
<li>prom's</li>\n<li>piranha's</li>\n<li>parade's</li>\n<li>Prague's</ 
li>
<li>Brahe's</li>\n<li>pirate's</li>\n<li>pride's</li>\n<li>prude's</li>
<li>puree's</li>\n<li>Price's</li>\n<li>Pryce's</li>\n<li>price's</li>
<li>prize's</li>
</ul> has only <span id='wrongword_2'>twoo</span><ul  
id='wrongword_2'><li>two</li>
<li>too</li>\n<li>woo</li>\n<li>twos</li>\n<li>two's</li>
</ul> <span id='wrongword_3'>incorrectlly</span><ul  
id='wrongword_3'><li>incorrectly</li>
<li>incorrect</li>\n<li>indirectly</li>\n<li>uncorrectable</li> 
\n<li>uncorrected</li>
<li>incorrigibly</li>
</ul> spelled words.
RESULT
     @result.chomp!
     # This is "bad" because it backtracks so much trying not to be  
greedy (*?)
     @bad_re = %r{\AThis <span id='wrongword_1'>prhase</span><ul  
id='wrongword_1'>(?:<li>.*?</li>\n?)+</ul> has only <span  
id='wrongword_2'>twoo</span><ul id='wrongword_2'>(?:<li>.*?</li>\n?) 
+</ul> incorrectlly spelled words.\z}ms
     # This is "good" because it's fast enough to know there is no match
     @good_re = %r{\AThis <span id='wrongword_1'>prhase</span><ul  
id='wrongword_1'>(?:<li>[^<]*</li>\n?)+</ul> has only <span  
id='wrongword_2'>twoo</span><ul id='wrongword_2'>(?:<li>[^<]*</li>\n?) 
+</ul> incorrectlly spelled words.\z}ms
   end

   def test_a_good_regexp
     assert_nothing_raised Timeout::Error do
       timeout(2) do
         assert_nil(@result =~ @good_re)
       end
     end
   end

   def test_a_timeout
     assert_raise Timeout::Error do
       timeout(2) do
         sleep 10
         flunk 'What about the timeout?'
       end
     end
   end

   def test_the_bad_regexp
     delay=5
     print "(timeout is #{delay}: interupt sooner and test fails,\n"
     print " count to #{2*delay} and then interupt it and the test  
PASSES!?)"
     $stdout.flush

     assert_raise Timeout::Error do
       timeout(delay) do
         # uncomment the sleep and see it timeout "properly"
         # sleep 2*delay
         assert_send [ @result, :=~, @bad_re ], "bad test or bad  
result?? "
       end
     end
     print "If there's a dot I pass => "; $stdout.flush
   end
end
__END__

Rob Biedenharn		http://agileconsultingllc.com
Rob@AgileConsultingLLC.com



--Apple-Mail-38--317248553--