Re: Clock skew failures in Memoize test suite

[p5sagit/p5-mst-13.2.git] / lib / Memoize / t / speed.t

diff --git a/lib/Memoize/t/speed.t b/lib/Memoize/t/speed.t
index 0456f2f..6d21906 100755 (executable)
--- a/lib/Memoize/t/speed.t
+++ b/lib/Memoize/t/speed.t
@@ -1,13 +1,7 @@
 #!/usr/bin/perl
 
-BEGIN {
-    chdir 't' if -d 't';
-    @INC = '../lib';
-}
+use lib '..';
 use Memoize;
-use strict;
-our $COUNT;
-our $RESULT;
 
 if (-e '.fast') {
   print "1..0\n";
@@ -18,10 +12,12 @@ $| = 1;
 # If we don't say anything, maybe nobody will notice.
 # print STDERR "\nWarning: I'm testing the speedup.  This might take up to thirty seconds.\n                    ";
 
+my $COARSE_TIME = 1;
+
 sub times_to_time { my ($u) = times; $u; }
 if ($^O eq 'riscos') {
   eval {require Time::HiRes; *my_time = \&Time::HiRes::time };
-  if ($@) { *my_time = sub { time }; }
+  if ($@) { *my_time = sub { time }; $COARSE_TIME = 1 }
 } else {
   *my_time = \&times_to_time;
 }
@@ -33,10 +29,10 @@ print "1..6\n";
 
 # This next test finds an example that takes a long time to run, then
 # checks to make sure that the run is actually speeded up by memoization.
-# In some sense, this is the most essential correctness test in the package.
+# In some sense, this is the most essential correctness test in the package.  
 #
-# We do this by running the fib() function with successively larger
-# arguments until we find one that takes at least $LONG_RUN seconds
+# We do this by running the fib() function with successfily larger
+# arguments until we find one that tales at least $LONG_RUN seconds
 # to execute.  Then we memoize fib() and run the same call cagain.  If
 # it doesn't produce the same test in less than one-tenth the time,
 # something is seriously wrong.
@@ -52,9 +48,13 @@ sub fib {
   fib($n-1) + fib($n-2);
 }
 
-our $N = 1;
+sub max { $_[0] > $_[1] ? 
+          $_[0] : $_[1] 
+        }
+
+$N = 1;
 
-our $ELAPSED = 0;
+$ELAPSED = 0;
 
 my $LONG_RUN = 10;
 
@@ -75,7 +75,7 @@ while (1) {
       # is exponential in $N.  If we increase $N too aggressively,
       # the user will be forced to wait a very long time.
   } else {
-      $N++;
+      $N++; 
   }
 }
 
@@ -85,16 +85,13 @@ print "# Total calls: $COUNT.\n";
 &memoize('fib');
 
 $COUNT=0;
-my $start = time;
-our $RESULT2 = fib($N);
-our $ELAPSED2 = (time - $start) || 1; # prevent division by 0 errors
+$start = time;
+$RESULT2 = fib($N);
+$ELAPSED2 = time - $start + .001; # prevent division by 0 errors
 
 print (($RESULT == $RESULT2) ? "ok 1\n" : "not ok 1\n");
 # If it's not ten times as fast, something is seriously wrong.
-print (($ELAPSED/$ELAPSED2 >= 10) ? "ok 2 - ELAPSED[$ELAPSED] ELAPSED2[$ELAPSED2]\n"
-       : "#
-# COUNT[$COUNT] N[$N] ELAPSED[$ELAPSED] ELAPSED2[$ELAPSED2]
-not ok 2\n");
+print (($ELAPSED/$ELAPSED2 > 10) ? "ok 2\n" : "not ok 2\n");
 # If it called the function more than $N times, it wasn't memoized properly
 print (($COUNT > $N) ? "ok 3\n" : "not ok 3\n");
 
@@ -102,10 +99,9 @@ print (($COUNT > $N) ? "ok 3\n" : "not ok 3\n");
 $COUNT = 0;
 $start = time;
 $RESULT2 = fib($N);
-$ELAPSED2 = (time - $start) || 1; # prevent division by 0 errors
+$ELAPSED2 = time - $start + .001; # prevent division by 0 errors
 
 print (($RESULT == $RESULT2) ? "ok 4\n" : "not ok 4\n");
-print (($ELAPSED/$ELAPSED2 >= 10) ? "ok 5 - ELAPSED[$ELAPSED] ELAPSED2[$ELAPSED2]\n"
-       : "not ok 5\n");
+print (($ELAPSED/$ELAPSED2 > 10) ? "ok 5\n" : "not ok 5\n");
 # This time it shouldn't have called the function at all.
 print ($COUNT == 0 ? "ok 6\n" : "not ok 6\n");