test.pl: Use END blocks to cancel watchdog timers

In doing follow up work to a7f3f23
"Turn off watchdog when done in tests", I realized that my solution was
suboptimal, and that the code already existed in test.pl to do things
better.

What that code does is to create an END block to cancel the watchdog
upon program exit.  I think that is a better solution than to force
the addition of explicit calls to watchdog(0).  This commit creates a
standard way to specify the code that does the cancellation, and to use
it, not only when the END block does, but also when the timer is
explicitly cancelled.  That standard method is to create a string that
basically gets evaled.   This entailed making any watchdog thread object
into a global so that a reference to it could be stringified for the
eval.

This means the calls to watchdog(0) that occur at the end of the file
that were added in a7f3f23 aren't
necessary.  The END block takes care of it.  The reason to keep them
would be if we want to add a porting test that every watchdog is cleared.

Author: khwilliamson

t/test.pl

@@ -1834,8 +1834,7 @@ sub warning_like {
 # NOTE:  If the test file uses 'threads', then call the watchdog() function
 #        _AFTER_ the 'threads' module is loaded.
 { # Closure
-    my $watchdog;
-    my $watchdog_thread;
+    my $cancel_string;
 
 sub watchdog ($;$)
 {
@@ -1844,29 +1843,18 @@ ($;$)
     # If cancelling, use the state variables to know which method was used to
     # create the watchdog.
     if ($timeout == 0) {
-        if ($watchdog_thread) {
-            $watchdog_thread->kill('KILL');
-            undef $watchdog_thread;
-        }
-        elsif ($watchdog) {
-            kill('KILL', $watchdog);
-            undef $watchdog;
-        }
-        else {
-            alarm(0);
-        }
-
+        eval $cancel_string if defined $cancel_string;
         return;
     }
 
-    # Make sure these aren't defined.
-    undef $watchdog;
-    undef $watchdog_thread;
-
     my $method = shift || "";
 
     my $timeout_msg = 'Test process timed out - terminating';
 
+    # Common to all cancellation types; HERE gets replaced by the individual
+    # code
+    $cancel_string = 'local $! = 0; local $? = 0; HERE; undef $cancel_string';
+
     # Accept either spelling
     my $timeout_factor = $ENV{PERL_TEST_TIME_OUT_FACTOR}
                       || $ENV{PERL_TEST_TIMEOUT_FACTOR}
@@ -1888,9 +1876,9 @@ ($;$)
     # shut up use only once warning
     my $threads_on = $threads::threads && $threads::threads;
 
-    # Don't use a watchdog process if 'threads' is loaded -
-    #   use a watchdog thread instead
+    # Use a watchdog process unless 'threads' is loaded
     if (!$threads_on || $method eq "process") {
+        my $watchdog;
 
         # On Windows and VMS, try launching a watchdog process
         #   using system(1, ...) (see perlport.pod).  system() returns
@@ -1909,7 +1897,6 @@ ($;$)
             return if ($pid_to_kill <= 0);
 
             # Launch watchdog process
-            undef $watchdog;
             eval {
                 local $SIG{'__WARN__'} = sub {
                     _diag("Watchdog warning: $_[0]");
@@ -1950,22 +1937,21 @@ ($;$)
                 return;
             }
 
-            # Add END block to parent to terminate and
-            #   clean up watchdog process
-            eval("END { local \$! = 0; local \$? = 0;
-                        wait() if kill('KILL', $watchdog); };");
+            # Add END block to parent to terminate and clean up watchdog
+            # process
+            $cancel_string =~ s/HERE/wait() if kill('KILL', $watchdog)/;
+            eval("END { $cancel_string };");
             return;
         }
 
         # Try using fork() to generate a watchdog process
-        undef $watchdog;
         eval { $watchdog = fork() };
         if (defined($watchdog)) {
             if ($watchdog) {   # Parent process
-                # Add END block to parent to terminate and
-                #   clean up watchdog process
-                eval "END { local \$! = 0; local \$? = 0;
-                            wait() if kill('KILL', $watchdog); };";
+                # Add END block to parent to terminate and clean up watchdog
+                # process
+                $cancel_string =~ s/HERE/wait() if kill('KILL', $watchdog)/;
+                eval("END { $cancel_string };");
                 return;
             }
 
@@ -2000,10 +1986,10 @@ ($;$)
         # fork() failed - fall through and try using a thread
     }
 
-    # Use a watchdog thread because either 'threads' is loaded,
-    #   or fork() failed
+    # Use a watchdog thread because either 'threads' is loaded, or fork()
+    # failed
     if (eval {require threads; 1}) {
-        $watchdog_thread = 'threads'->create(sub {
+        $::watchdog_thread_ = 'threads'->create(sub {
                 # Load POSIX if available
                 eval { require POSIX; };
 
@@ -2027,12 +2013,15 @@ ($;$)
                 kill($sig, $pid_to_kill);
         });
 
+        $cancel_string =~ s/HERE/$::watchdog_thread_->kill('KILL')->detach()/;
+        eval "END { $cancel_string }";
+
         # Don't proceed until the watchdog has set up its signal handler.
         # (Otherwise there is a possibility that we will exit with threads
         # running.)  The watchdog tells us that the handler is set by
         # detaching itself.  (The 'is_running()' is a fail-safe.)
-        while (     $watchdog_thread->is_running()
-               && ! $watchdog_thread->is_detached())
+        while (     $::watchdog_thread_->is_running()
+               && ! $::watchdog_thread_->is_detached())
         {
             'threads'->yield();
         }
@@ -2054,6 +2043,9 @@ ($;$)
             my $sig = $is_vms ? 'TERM' : 'KILL';
             kill($sig, $pid_to_kill);
         };
+
+        $cancel_string =~ s/HERE/alarm(0)/;
+        eval "END { $cancel_string }";
     }
 }
 } # End closure