#!/usr/local/bin/perl -w
use strict; 

my $DOC = <<"EOF"; 
Usage: $0 <pkg (no tilde)> <cln app dir (no tilde)> <table dir (no tilde)> [extra]

Run first: 
- make_packages (assumes this was run on the mut dir created by instr_mutants)

Args: 
- <pkg>, the package for which to generate and run test cases
- <cln app dir>, the dir containing the clean, instrumented version of the application (bin-ins) and related files (input_files, config_files, <app name>.gui, <app name>.efg, orc_sub.txt, main_class, lib_cp, and optionally var_defs)
- <table dir>, the dir containing table file faults.txt (from tables/faults) and explore_test_suite_sizes.txt
- 'extra', optional, if this arg is given then assumes replay is to be resumed and skips right to the extra test cases, using the number currently defined in <pkg>/num_extra_tsts.txt

Constants: 
- <max num>, the maximum number of test cases to try (depends on the application)
- <tmp dir>, <R dir>, <JavaClassFiles dir>, <emma dir>, and <script dir> (depends on the user's preference)
- <debug>, whether to run in debug (interactive) mode

Affects: 
- <pkg>/tst, a dir that contains all test cases that ran successfully on the clean version 
- <pkg>/discarded_tst, a dir that contains all test cases that were generated but failed to run on the clean version
- <pkg>/cov-cln & <pkg>/cov-mut, dirs that contain coverage files for all test cases in <pkg>/tst that ran successfully on the clean version (-cln) and at least partially on the mutant version (-mut)
- <pkg>/log-cln & <pkg>/log-mut, dirs that contain logged output (stdout + stderr) for all test cases that ran successfully on the clean version
- <pkg>/orc-cln & <pkg>/orc-mut, dirs that contain oracle information for all test cases that covered the faulty line, except those such that <pkg>/orc-cln/<TstNum>.orc and <pkg>/orc-mut/<TstNum>.orc were identical after post-processing
- <pkg>/replay_result.txt, which is a table with the following header items: 
  + TstNum, >= 0, corresponding to file <pkg>/<TstNum>.tst
  + Covered, 1 if the faulty line is covered by the test case, 0 otherwise
  + Detected, 1 if the fault MAY BE detected by the test case (in which case <pkg>/orc-cln/<TstNum>.orc and <pkg>/orc-mut/<TstNum>.orc exist), 0 otherwise
- <pkg>/events_not_covered.txt, a list of all GUI events not covered by the test cases in <pkg>/tst, empty if all events are covered
- <pkg>/num_extra_tsts.txt, a file containing the number of "extra" test cases to be generated in the second phase to pad out the test-suite size

Iteratively creates and attempts to run test cases of length specified
in <pkg>/tst_len until either all events are covered and then the
number of extra test cases calculated by num_extra_tsts.R are
successfully run, or <max num> test cases are tried, where <max num>
is calculated from <table dir>/explore_test_suite_sizes.txt. Before
being run, each test case is checked to make sure it is not identical
to an existing test case; if it is, it is deleted and a new one is
generated. When a test case is generated, it is first run on the clean
version of the app. If it does not run successfully to completion,
then it is discarded and <pkg>/events_not_covered.txt is restored to
its prior state. If it runs successfully but does not cover the faulty
line (or class for extra-method faults), then <pkg>/replay_result.txt
is made to say that the fault is not covered, and the oracle-info file
is deleted. If it runs successfully and does cover the faulty line (or
class), then it is run on the mutant version (<pkg>/mut_class with
<cln app dir>/bin). The oracle-info files are post-processed. If the
oracle-info files are identical after post-processing, then
<pkg>/replay_result.txt is made to say that the fault is not detected,
and the oracle-info files are deleted. All files and directories in
<pkg> created by this script are made read-only before being zipped
back up.

Assumes <pkg> has name <fault num>.zip and contains a directory named
<fault num>.

If <pkg>/tst already exists, resumes execution of a (presumably)
previously-replayed package that failed to cover all events. 
EOF
;

if (@ARGV != 3 && @ARGV != 4) {
    print $DOC; 
    exit 1; 
}

my ($pkg, $cln_app_dir, $table_dir, $skip_to_extra) = @ARGV; 
if (@ARGV == 4 && $skip_to_extra ne 'extra') {
    print $DOC; 
    exit 1; 
}
$skip_to_extra = (defined $skip_to_extra ? 1 : 0); 
$cln_app_dir =~ s|/$||; 
$table_dir =~ s|/$||; 
my $TMP_DIR = '/tmp/strecker'; 
my $R_DIR = '/skollhomes/strecker'; 
my $EMMA_DIR = '/skollhomes/strecker'; 
my $JAVACLASSFILES = '/skollhomes/strecker/JavaClassFiles'; 
my $SCRIPT_DIR = '/skollhomes/strecker/Jaymie_BigExpt/scripts'; 
my $DEBUG = 0; 

my $app_name = `basename $cln_app_dir`; 
chomp $app_name; 
my $tst_step_pause, my $tst_step_timeout, my $tst_initial_pause; 
if ($DEBUG) {
    $tst_step_pause = 500; 
    $tst_step_timeout = 2000; 
    $tst_initial_pause = 1000;
} else { 
    $tst_step_pause = 2500; 
    $tst_step_timeout = 15000; 
    $tst_initial_pause = 5000;
}
if ($app_name eq 'freemind-0.8.0') {
    $tst_step_pause = 2 * $tst_step_pause; 
    $tst_step_timeout = 2 * $tst_step_timeout; 
    $tst_initial_pause = 4 * $tst_initial_pause; 
}

print "Started $pkg! " . `date`; 
my $pkg_name = `basename $pkg`; 
chomp $pkg_name; 
$pkg_name =~ s/\.zip$//; 
my $pkg_dir = "$TMP_DIR/$pkg_name";  # Must be an absolute path for other stuff to work
if (-e $pkg_dir) {
    `chmod -R u+w $pkg_dir`; 
    `rm -r $pkg_dir`; 
    die "Couldn't do rm -r $pkg_dir\n"  if ($?); 
}
`unzip -d $TMP_DIR $pkg`; 
die "Couldn't do unzip -d $TMP_DIR $pkg\n"  if ($?); 

my $fault_num = $pkg_name; 
my $fault_file = "$table_dir/faults.txt"; 
my $head = `head -n 1 $fault_file`; 
chomp $head; 
die "Unknown header in $fault_file\n"  if ($head !~ m/^FaultNum\s+Line\s+MutType\s+InMethod(\s+.*)$/); 
my $fault_row = `grep "^$fault_num " $fault_file`; 
chomp $fault_row; 
my ($n, $fault_line, $m, $fault_in_method) = split(/\s/, $fault_row); 

my $gui_file = "$cln_app_dir/$app_name.gui"; 
my $efg_file = "$cln_app_dir/$app_name.efg"; 
my $orc_sub_file = "$cln_app_dir/orc_sub.txt"; 
my $app_lib_cp = `cat $cln_app_dir/lib_cp`; 
chomp $app_lib_cp; 
my $app_main_class = `cat $cln_app_dir/main_class`; 
chomp $app_main_class; 
my $app_var_defs = ''; 
if (-e "$cln_app_dir/var_defs") {
    $app_var_defs = `cat $cln_app_dir/var_defs`; 
    chomp $app_var_defs; 
}
my $tst_len = `cat $pkg_dir/tst_len.txt`; 
chomp $tst_len; 
my $MAX_NUM; 
if ($app_name eq 'crosswordsage-0.3.5') {
    my $MAX_EVENTS = 5600;  # 10(mean + 2 sqrt(variance)) for TstLen=20 in tables/cws/explore_suite_sizes.txt
    $MAX_NUM = $MAX_EVENTS / $tst_len; 
} elsif ($app_name eq 'freemind-0.7.1') {
    my $MAX_EVENTS = 9982;  # 10(mean + 2 sqrt(variance)) for TstLen=20 in tables/fm7/explore_suite_sizes.txt
    $MAX_NUM = $MAX_EVENTS / $tst_len; 
} elsif ($app_name eq 'freemind-0.8.0') {
    my $MAX_EVENTS = 20000;  # fm8's EFG is about 2 times the size of fm7's
    $MAX_NUM = $MAX_EVENTS / $tst_len; 
} else {
    die "I don't know what $MAX_NUM should be for $app_name\n"; 
}

my $tst_dir = "$pkg_dir/tst"; 
my $discarded_tst_dir = "$pkg_dir/discarded_tst"; 
my $cov_cln_dir = "$pkg_dir/cov-cln"; 
my $cov_mut_dir = "$pkg_dir/cov-mut"; 
my $log_cln_dir = "$pkg_dir/log-cln"; 
my $log_mut_dir = "$pkg_dir/log-mut"; 
my $orc_cln_dir = "$pkg_dir/orc-cln"; 
my $orc_mut_dir = "$pkg_dir/orc-mut"; 
my $replay_dir = "$pkg_dir/replay"; 
my $replay_result_file = "$pkg_dir/replay_result.txt"; 
my $uncov_file = "$pkg_dir/events_not_covered.txt"; 
my $time_log_file = "$pkg_dir/time_log.txt"; 
my $succ_log_file = "$pkg_dir/succ_log.txt"; 
my $extra_tsts_file = "$pkg_dir/num_extra_tsts.txt"; 
my $num_events_uncov; 
my $num_tsts_tried, my $num_tsts_succ; 

if (-e $tst_dir) {
    print "Resuming replay\n"; 
    if (! (-e $cov_cln_dir && -e $cov_mut_dir && -e $log_cln_dir && -e $log_mut_dir && -e $orc_cln_dir && -e $orc_mut_dir && -e $replay_result_file && -e $uncov_file)) {
        die "Trying to resume replay, but one of the following does not exist: $cov_cln_dir $cov_mut_dir $log_cln_dir $log_mut_dir $orc_cln_dir $orc_mut_dir $replay_result_file $uncov_file\n"; 
    }
    `chmod u+w $tst_dir $cov_cln_dir $cov_mut_dir $log_cln_dir $log_mut_dir $orc_cln_dir $orc_mut_dir $replay_result_file $uncov_file $time_log_file $succ_log_file`; 
    if (-e $discarded_tst_dir) {
        `chmod -R u+w $discarded_tst_dir`; 
	`rm -r $discarded_tst_dir`; 
	die "Trying to resume replay, but couldn't do rm -r $discarded_tst_dir\n"  if ($?); 
    }
    `mkdir $discarded_tst_dir`; 
    die "Trying to resume replay, but couldn't do mkdir $discarded_tst_dir\n"  if ($?); 
    if (-e $replay_dir) {
        `chmod -R u+w $replay_dir`; 
        `rm -r $replay_dir`; 
        die "Trying to resume replay, but couldn't do rm -r $replay_dir\n"  if ($?); 
    }
    if (! $skip_to_extra && -e $extra_tsts_file) {
        `chmod u+w $extra_tsts_file`; 
	`rm $extra_tsts_file`; 
	die "Trying to resume replay, but couldn't do rm $extra_tsts_file\n"  if ($?); 
    }
    if (-e "$uncov_file.bak") {
        `chmod u+w $uncov_file.bak`; 
	`rm $uncov_file.bak`; 
	die "Trying to resume replay, but couldn't do rm $uncov_file.bak\n"  if ($?); 
    }
    if (! -e $replay_result_file) {
        die "Trying to resume replay, but $replay_result_file does not exist\n"; 
    }
    open(REPLAY_RESULT, ">>$replay_result_file") or die "Couldn't append to $replay_result_file\n"; 

    $num_tsts_tried = newest_tst_num() + 1; 
    $num_tsts_succ = $num_tsts_tried; 
} else {
    `mkdir $tst_dir $discarded_tst_dir $cov_cln_dir $cov_mut_dir $log_cln_dir $log_mut_dir $orc_cln_dir $orc_mut_dir`; 
    die "Couldn't do mkdir $tst_dir $cov_cln_dir $cov_mut_dir $log_cln_dir $log_mut_dir $orc_cln_dir $orc_mut_dir\n"  if ($?); 

    if (-e $replay_result_file) {
        `rm $replay_result_file`; 
        die "Couldn't do rm $replay_result_file\n"  if ($?); 
    }
    open(REPLAY_RESULT, ">$replay_result_file") or die "Couldn't write to $replay_result_file\n"; 
    print REPLAY_RESULT "TstNum Covered Detected\n"; 

    $num_tsts_tried = 0; 
    $num_tsts_succ = 0; 
}

my $num_extra_tsts, my $num_tsts_req; 
if ($skip_to_extra) {
    die "$extra_tsts_file does not exist\n"  if (! -e $extra_tsts_file); 
    $num_extra_tsts = `cat $extra_tsts_file`; 
    chomp $num_extra_tsts; 
    $num_tsts_req = $num_tsts_succ + $num_extra_tsts; 
} else {

do {
    backup_events_uncov(); 
    my $succ_gen = gen_tst(); 
    if ($DEBUG) {
        print "DEBUG: succ_gen=$succ_gen\n"; 
        print "DEBUG: Press enter/return...\n"; 
        my $go = <STDIN>; 
    }
    if ($succ_gen) {
	my $succ = run_tst(); 
        if ($DEBUG) {
            print "DEBUG: succ=$succ\n"; 
            print "DEBUG: Press enter/return...\n"; 
            my $go = <STDIN>; 
        }
	if ($succ) {
	    $num_tsts_succ++; 
	    update_events_uncov(); 
	} else {
	    recover_events_uncov(); 
	}
    } else {
	recover_events_uncov(); 
    }
    $num_tsts_tried++; 
    if ($DEBUG) {
        print "DEBUG: num_tsts_tried=$num_tsts_tried, num_tsts_succ=$num_tsts_succ\n"; 
    } else {
        print "$num_tsts_tried test cases tried, $num_tsts_succ test cases succeeded " . `date`  if ($num_tsts_tried % 10 == 0); 
    }
} while ((! defined $num_events_uncov || $num_events_uncov > 0) && $num_tsts_tried < $MAX_NUM); 

$num_extra_tsts = `$R_DIR/R --no-save --slave --args $table_dir $tst_len $num_tsts_succ < $SCRIPT_DIR/num_extra_tsts.R`; 
chomp $num_extra_tsts; 
$num_tsts_req = $num_tsts_succ + $num_extra_tsts; 
`echo "$num_extra_tsts" > $extra_tsts_file`; 
print "$num_tsts_tried test cases tried, $num_tsts_succ test cases succeeded, $num_tsts_req test cases required " . `date`; 

}

while ($num_tsts_succ < $num_tsts_req && $num_tsts_tried < $MAX_NUM) {
    my $succ_gen = gen_tst(); 
    if ($DEBUG) {
        print "DEBUG: succ_gen=$succ_gen\n"; 
        print "DEBUG: Press enter/return...\n"; 
        my $go = <STDIN>; 
    }
    if ($succ_gen) {
	my $succ = run_tst(); 
        if ($DEBUG) {
            print "DEBUG: succ=$succ\n"; 
            print "DEBUG: Press enter/return...\n"; 
            my $go = <STDIN>; 
        }
	if ($succ) {
	    $num_tsts_succ++; 
	}
    }
    $num_tsts_tried++; 
    if ($DEBUG) {
        print "DEBUG: num_tsts_tried=$num_tsts_tried, num_tsts_succ=$num_tsts_succ\n"; 
    } else {
        print "$num_tsts_tried test cases tried, $num_tsts_succ test cases succeeded " . `date`  if ($num_tsts_tried % 10 == 0);
    }
}

close(REPLAY_RESULT); 
cleanup(); 

chdir($TMP_DIR) or die "Couldn't do chdir($TMP_DIR)\n"; 
`zip -r $pkg $pkg_name`; 
die "Couldn't do zip -r $pkg $pkg_name\n"  if ($?); 
`chmod -R u+w $pkg_name`; 
`rm -r $pkg_name`; 
print "Finished! " . `date`; 


# Tries to generate a test case. If this is successful, the new test
# case is the last numerically in $tst_dir, and 1 is returned. If the
# test case is identical to one already in $tst_dir or
# $discarded_tst_dir, $tst_dir is unchanged and 0 is returned.

sub gen_tst {
    my $prev_new_tst_num = newest_tst_num(); 
    my $out=`java -Xmx512m -ea -cp $JAVACLASSFILES:$JAVACLASSFILES/jdom.jar:$JAVACLASSFILES/xercesImpl.jar JaymieTestCaseGenerator -n 1 -l $tst_len -g $gui_file -e $efg_file -d $tst_dir -u $uncov_file 2>&1`;  
    ## $? seems to be unreliable here-- sometimes it's -1 and I don't know why
    my $new_tst_num = newest_tst_num(); 
    die "Couldn't do java -Xmx512m -ea -cp $JAVACLASSFILES:$JAVACLASSFILES/jdom.jar:$JAVACLASSFILES/xercesImpl.jar JaymieTestCaseGenerator -n 1 -l $tst_len -g $gui_file -e $efg_file -d $tst_dir -u $uncov_file\n$out"  if ($new_tst_num != $prev_new_tst_num + 1); 
    my $new_tst_file = "$tst_dir/$new_tst_num.tst"; 
    if ($DEBUG) {
	print "DEBUG: gen_tst.new_tst_file=$new_tst_file\n"; 
	print "DEBUG: Press enter/return...\n"; 
	my $go = <STDIN>; 
    }
    my @tst_files = <$tst_dir/*>; 
    my @discarded_tst_files = <$discarded_tst_dir/*>; 
    push @tst_files, @discarded_tst_files; 
    foreach my $tst_file (@tst_files) {
	next  if ($new_tst_file eq $tst_file); 
	`diff -q $new_tst_file $tst_file`; 
	my $err = $? >> 8; 
	if ($err == 0) {
	    `rm $new_tst_file`; 
	    return 0; 
	} elsif ($err!= 1) {
	    die "Couldn't do diff -q $new_tst_file $tst_file\n"; 
	}
    }
    return 1; 
}


# Tries to run (on the clean version and possibly the mutant version)
# the test case that is last numerically in $tst_dir. If it runs to
# completion on the clean version and coverage is successfully
# collected, then files are created in $cov_cln_dir, $log_cln_dir, and
# $orc_cln_dir, and 1 is returned after further steps are performed
# (specified in a moment). Otherwise, these dirs are unchanged, the
# test case in $tst_dir is moved to a uniquely named file in
# $discarded_tst_dir, and 0 is returned. In the former case, the
# coverage file is checked to see whether the faulty line was
# covered. If it was not, then $replay_result_file is updated to say
# so, and the oracle file in $orc_cln_dir is deleted. Otherwise, the
# test case is run on the mutant version, files are created in
# $cov_mut_dir, $log_mut_dir, and $orc_mut_dir, and the files in
# $orc_cln_dir and $orc_mut_dir are post-processed and
# diffed. $replay_result_file is updated based on the result. If the
# files in $orc_cln_dir and $orc_mut_dir are identical, then the
# oracle files are deleted.

sub run_tst {
    my $tst_num = newest_tst_num(); 
    my $succ = replay_tst('cln'); 
    if (! $succ) {
	if ($DEBUG) {
	    print "DEBUG: run_tst.succ=$succ (cln)\n"; 
	    print "DEBUG: Press enter/return...\n"; 
	    my $go = <STDIN>; 
	}
	if (-e "$cov_cln_dir/$tst_num.txt") {
	    `rm $cov_cln_dir/$tst_num.*`; 
	}
	if (-e "$log_cln_dir/$tst_num.txt") {
	    `rm $log_cln_dir/$tst_num.txt`; 
	}
	if (-e "$orc_cln_dir/$tst_num.orc") {
	    `rm $orc_cln_dir/$tst_num.orc`; 
	}
	my $timestamp = `date +%F-%T`; 
	chomp $timestamp; 
	`mv $tst_dir/$tst_num.tst $discarded_tst_dir/$tst_num.tst_$timestamp`; 
	die "Couldn't do mv $tst_dir/$tst_num.tst $discarded_tst_dir/$tst_num.tst_$timestamp/\n"  if ($?); 
	return 0; 
    }
    if ($DEBUG) {
	print "DEBUG: run_tst.succ=$succ (cln)\n"; 
	print "DEBUG: Press enter/return...\n"; 
	my $go = <STDIN>; 
    }
    my $cov = fault_line_covered(); 
    if (! $cov) {
	print REPLAY_RESULT "$tst_num 0 0\n"; 
	`rm $orc_cln_dir/$tst_num.orc`; 
	return 1; 
    }
    $succ = replay_tst('mut'); 
    if ($DEBUG) {
	print "DEBUG: run_tst.succ=$succ (mut)\n"; 
	print "DEBUG: Press enter/return...\n"; 
	my $go = <STDIN>; 
    }
    if (-e $orc_sub_file) {
	`perl -p -i $orc_sub_file $orc_cln_dir/$tst_num.orc $orc_mut_dir/$tst_num.orc`; 
	die "Couldn't do perl -p -i $orc_sub_file $orc_cln_dir/$tst_num.orc $orc_mut_dir/$tst_num.orc\n"  if ($?); 
    }
    `diff -q $orc_cln_dir/$tst_num.orc $orc_mut_dir/$tst_num.orc`; 
    my $err = $? >> 8; 
    if ($DEBUG) {
	print "DEBUG: run_tst.err=$err\n"; 
	print "DEBUG: Press enter/return...\n"; 
	my $go = <STDIN>; 
    }
    if ($err == 0) {
	print REPLAY_RESULT "$tst_num 1 0\n"; 
	`rm $orc_cln_dir/$tst_num.orc $orc_mut_dir/$tst_num.orc`; 
	return 1; 
    } elsif ($err != 1) {
	die "Couldn't do diff -q $orc_cln_dir/$tst_num.orc $orc_mut_dir/$tst_num.orc\n"; 
    }
    print REPLAY_RESULT "$tst_num 1 1\n"; 
    return 1; 
}


# Runs the test case that is last numerically in $tst_dir in a
# semi-safe environment ($replay_dir) for the given version of the
# application (either 'cln' or 'mut'). First, copies the application's
# input and config files to $replay_dir and gives them write
# permissions. Then, runs the application from within $replay_dir and
# changes back to the previous dir. Finally, processes the coverage
# data to put in $cov_cln_dir or $cov_mut_dir and deletes
# $replay_dir. Returns 1 if the resulting oracle file contains at
# least $tst_len complete steps and the corresponding coverage files
# exist, 0 otherwise.

# This has a bug! When returning 0, it can return before coverage
# files are processed and wrongly delete coverage files. Considering
# how the function is used, this is not a problem for the clean
# version, only for the mutant version if its coverage is to be
# accurate.

sub replay_tst {
    my $version = shift; 

    `mkdir $replay_dir`; 
    `cp -r $cln_app_dir/input_files $cln_app_dir/config_files/* $replay_dir/`; 
    die "Couldn't do cp -r $cln_app_dir/input_files $cln_app_dir/config_files/* $replay_dir/\n"  if ($?); 
    `chmod -R u+w $replay_dir/*`; 
    
    my $tst_num = newest_tst_num(); 
    my $log_dir, my $orc_dir, my $cov_dir, my $cp; 
    if ($version eq 'cln') { 
	$log_dir = $log_cln_dir; 
	$orc_dir = $orc_cln_dir; 
	$cov_dir = $cov_cln_dir; 
    } else {
	$log_dir = $log_mut_dir; 
	$orc_dir = $orc_mut_dir; 
	$cov_dir = $cov_mut_dir; 
	$cp = "$pkg_dir/mut_class:"
    }
    $cp .= "$cln_app_dir/bin-ins:$app_lib_cp:$EMMA_DIR/emma.jar:$JAVACLASSFILES:$JAVACLASSFILES/jdom.jar:$JAVACLASSFILES/xercesImpl.jar"; 
    my $orc_file = "$orc_dir/$tst_num.orc"; 

    my $pwd_dir = `pwd`; 
    chomp $pwd_dir; 
    chdir("$replay_dir") or die "Couldn't do chdir($replay_dir)\n"; 
    if ($DEBUG) {
	print "DEBUG: java -Xmx512m -Dswing.defaultlaf=javax.swing.plaf.metal.MetalLookAndFeel $app_var_defs -cp $cp JavaGUIReplayer -f $tst_dir/$tst_num.tst -c $app_main_class -o $orc_dir/$tst_num.orc -t $time_log_file -v $succ_log_file -u file:$cln_app_dir/bin-ins -p $tst_step_pause -e $tst_step_timeout -h $tst_initial_pause -d -i $cov_dir/$tst_num.txt -b >& $log_dir/$tst_num.txt\n"; 
    }
    `java -Xmx512m -Dswing.defaultlaf=javax.swing.plaf.metal.MetalLookAndFeel $app_var_defs -cp $cp JavaGUIReplayer -f $tst_dir/$tst_num.tst -c $app_main_class -o $orc_dir/$tst_num.orc -t $time_log_file -v $succ_log_file -u file:$cln_app_dir/bin-ins -p $tst_step_pause -e $tst_step_timeout -h $tst_initial_pause -d -i $cov_dir/$tst_num.txt -b >& $log_dir/$tst_num.txt`; 
    chdir("$pwd_dir") or die "Couldn't do chdir($pwd_dir)\n"; 

    for (my $i = 1; $i <= $tst_len - 1; $i++) {
	if (! -e "$cov_dir/$tst_num.txt-$i") {
	    `rm -r $replay_dir`; 
	    die "Couldn't do rm -r $replay_dir\n"  if ($?); 
	    return 0; 
	}
    }

    if (! -e "$replay_dir/coverage.ec" || 
	! (-e "$replay_dir/_prof.out" || -e "$cov_dir/$tst_num.txt-$tst_len")) {
	`rm -r $replay_dir`; 
	die "Couldn't do rm -r $replay_dir\n"  if ($?); 
	return 0; 
    }

    if (-e "$replay_dir/_prof.out") {
	`mv $replay_dir/_prof.out $cov_dir/$tst_num.txt-final`; 
	die "Couldn't do mv $replay_dir/_prof.out $cov_dir/$tst_num.txt-final\n"  if ($?); 
    }
    `mv $replay_dir/coverage.ec $cov_dir/$tst_num.ec`; 
    die "Couldn't do mv $replay_dir/coverage.ec $cov_dir/$tst_num.ec\n"  if ($?); 
    foreach my $cov_file (<$cov_dir/$tst_num.txt*>) {
	`mv $cov_file $cov_file.old`; 
	`egrep -v ' 0\$' $cov_file.old > $cov_file`; 
	my $err = $? >> 8; 
	die "Couldn't do egrep -v ' 0\$' $cov_file.old > $cov_file\n"  if ($err != 0 && $err != 1); 
	`rm $cov_file.old`; 
    }
    `rm -r $replay_dir`; 
    die "Couldn't do rm -r $replay_dir\n"  if ($?); 

    my $num_orc_step_close = `grep -c '</Step>' $orc_file`; 
    chomp $num_orc_step_close; 
    my $num_orc_testsuite_close = `grep -c '</Testsuite>' $orc_file`; 
    chomp $num_orc_testsuite_close; 
    $num_orc_step_close--  if ($num_orc_testsuite_close < 1); 
    if ($num_orc_step_close >= $tst_len) {
	return 1; 
    }
    return 0; 
}


# Returns 1 if some coverage file in $cov_cln_dir for the test case
# last numerically in $tst_dir says that $fault_line is covered, 0
# otherwise. Assumes that lines in the coverage files where the number
# of times covered is 0 have been removed.

sub fault_line_covered {
    my $tst_num = newest_tst_num(); 
    my $fault_line_str = $fault_line; 
    if ($fault_in_method) {
	$fault_line_str =~ s/:/ /; 
    } else {
	$fault_line_str =~ s/:.*//; 
    }
    `grep -l "^$fault_line_str " $cov_cln_dir/$tst_num.txt*`; 
    my $err = $? >> 8; 
    if ($err == 0) {
	return 1; 
    } elsif ($err == 2) {
	die "Couldn't do grep -l \"^$fault_line_str \" $cov_cln_dir/$tst_num.txt*\n"; 
    }
    return 0; 
}


# Returns the number (<num> in file name <num>.tst) in $tst_dir, based
# on the convention that test cases are numbered in order starting
# from 0. Returns -1 if $tst_dir is empty. 

sub newest_tst_num {
    my @tst_files = <$tst_dir/*>; 
    return scalar(@tst_files) - 1; 
}


sub backup_events_uncov {
    if (-e $uncov_file) {
	`cp $uncov_file $uncov_file.bak`; 
    }
}

sub update_events_uncov {
    $num_events_uncov = `cat $uncov_file | wc -l`;  
    chomp $num_events_uncov; 
}

sub recover_events_uncov {
    if (-e "$uncov_file.bak") {
	`cp $uncov_file.bak $uncov_file`; 
    } else {
	`rm $uncov_file`; 
    }
}

sub cleanup {
    `rm -rf $uncov_file.bak`; 
    `rm -r $replay_dir`; 
    `chmod -R a-w $tst_dir $discarded_tst_dir $cov_cln_dir $cov_mut_dir $log_cln_dir $log_mut_dir $orc_cln_dir $orc_mut_dir $replay_result_file $uncov_file $time_log_file $succ_log_file $extra_tsts_file`; 
}