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

my $DOC = <<"EOF"; 
Usage: $0 <pkg> <app dir> <table dir>

Run first: 
- replay_package

Args: 
- <pkg>, the replayed package to which the oracle should be applied
- <app dir>, which contains orc_sub.txt and ignore.xml, the ignore file to use with oracle.Comparer
- <table dir>, which contains faults.txt and explore_test_suite_sizes.txt

Constants: 
- <tmp dir>, <R dir>, <JavaClassFiles dir>, and <script dir> (depends on the user's preference)

Affects: 
- <pkg>/orc-diff, a dir where each file contains output (stdout + stderr) from running oracle.Comparer on the corresponding files in <pkg>/orc-cln and <pkg>/orc-mut
- <pkg>/result.txt, a table with the following header items: 
  + TstNum, >= 1, corresponding to file <pkg>/<TstNum>.tst
  + Covered1, ..., CoveredN, (N=tst_len) 1 if the faulty line is covered by the test case, 0 otherwise
  + Detected1, ..., DetectedN, (N=tst_len) 1 if the fault is detected by the test case, 0 if it is not detected, -1 if it is supposedly detected but its line hasn't been covered yet

Runs the oracle on the package, checking along the way that the
package ran successfully. Prints an error if
<pkg>/events_not_covered.txt is not an existing, empty file, if
<pkg>/num_extra_tsts.txt does not exist, or if the number of files in
<pkg>/tsts is inconsistent with either <pkg>/num_extra_tsts.txt or
<pkg>/replay_result.txt. For each entry in <pkg>/replay_result.txt,
checks that the existence of files in <pkg>/tst, <pkg>/orc-cln, and
<pkg>/orc-mut is consistent with that entry; if not, prints an error
and moves on to the next entry. Otherwise, looks at the coverage files
in <pkg>/cov-cln for the entry to determine coverage for each step,
checking that these files exist and printing an error if not. If the
corresponding files in <pkg>/orc-cln and <pkg>/orc-mut exist, runs
oracle.Comparer with <ignore file> on these to get differences for
each step in the test case; stores the output in
<pkg>/orc-diff. Reports coverage and difference (detection)
information for each step to <pkg>/result.txt. If there is a
difference in step S but the faulty line is not covered until step T
(T>S), reports Detected=-1 for steps S through T-1.
EOF
    ;

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

my ($pkg, $app_dir, $table_dir) = @ARGV; 
$app_dir =~ s|/$||; 
$table_dir =~ s|/$||; 
my $TMP_DIR = '/tmp/strecker'; 
my $SCRIPT_DIR = '/skollhomes/strecker/Jaymie_BigExpt/scripts'; 
my $R_DIR = '/skollhomes/strecker'; 
my $JAVACLASSFILES = '/skollhomes/strecker/JavaClassFiles'; 
print "Started $pkg! " . `date`; 

my $pkg_name = `basename $pkg`; 
chomp $pkg_name; 
$pkg_name =~ s/\.zip$//; 
my $pkg_dir = "$TMP_DIR/$pkg_name"; 
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`; 
my $app_name = `basename $app_dir`; 
chomp $app_name; 
my $uncov_file = "$pkg_dir/events_not_covered.txt"; 
my $tst_len = `cat $pkg_dir/tst_len.txt`; 
chomp $tst_len; 
my $tst_dir = "$pkg_dir/tst"; 
my $orc_cln_dir = "$pkg_dir/orc-cln"; 
my $orc_mut_dir = "$pkg_dir/orc-mut"; 
my $cov_cln_dir = "$pkg_dir/cov-cln"; 
my $cov_mut_dir = "$pkg_dir/cov-mut"; 
my $extra_tsts_file = "$pkg_dir/num_extra_tsts.txt"; 
my $replay_result_file = "$pkg_dir/replay_result.txt"; 
my $result_file = "$pkg_dir/result.txt"; 
if (-e $result_file) {
    `chmod u+w $result_file`; 
    `rm $result_file`; 
    die "FATAL ERROR: Couldn't do rm $result_file\n"  if ($?); 
}
my $orc_diff_dir = "$pkg_dir/orc-diff"; 
if (-e $orc_diff_dir) {
    `chmod -R u+w $orc_diff_dir`; 
    `rm -r $orc_diff_dir`; 
    die "FATAL ERROR: Couldn't do rm -r $orc_diff_dir\n"  if ($?); 
}
`mkdir $orc_diff_dir`; 
die "FATAL ERROR: Couldn't do mkdir $orc_diff_dir\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 $ignore_file = "$app_dir/ignore.xml"; 
my $ignore_option; 
if (-e $ignore_file) {
    $ignore_option = "-i $ignore_file"; 
} else {
    $ignore_option = ""; 
    print "WARNING: $app_dir/ignore.xml does not exist\n"; 
}
my $orc_sub_file = "$app_dir/orc_sub.txt"; 

if (! -e $uncov_file) {
    print "ERROR: $uncov_file does not exist\n"; 
} else {
    my $out = `cat $uncov_file | wc -l`; 
    chomp $out; 
    if ($out != 0) {
        print "ERROR: $uncov_file is non-empty ($out lines)\n"; 
    } 
}

my $num_tsts = `ls $tst_dir | wc -l`; 
chomp $num_tsts; 

if (! -e $extra_tsts_file) {
    print "ERROR: $extra_tsts_file does not exist\n"; 
} else {
    my $num_extra_tsts = `cat $extra_tsts_file`; 
    chomp $num_extra_tsts; 
    if ($num_extra_tsts eq 'Inf') {
	print "ERROR: $extra_tsts_file says Inf\n"; 
    } else {
	my $num_non_extra_tsts = $num_tsts - $num_extra_tsts; 
	my $pred_num_extra_tsts = `$R_DIR/R --no-save --slave --args $table_dir $tst_len $num_non_extra_tsts < $SCRIPT_DIR/num_extra_tsts.R`; 
	if ($pred_num_extra_tsts != $num_extra_tsts) {
	    print "ERROR: number of files in $tst_dir ($num_tsts) is inconsistent with $extra_tsts_file ($num_extra_tsts)\n"; 
	}
    }
}

if (! -e $replay_result_file) {
    die "FATAL ERROR: $replay_result_file does not exist\n"; 
} else {
    my $out = `cat $replay_result_file | wc -l`; 
    chomp $out; 
    if ($out != $num_tsts + 1) {
        print "ERROR: number of files in $tst_dir ($num_tsts) is inconsistent with $replay_result_file ($out lines)\n"; 
    }
}

# Remove 0-times-covered lines from coverage files, since
# replay_package sometimes fails to do this (at least for
# freemind-0.7.1 muts). 
### BEGIN cloned from replay_package ###
foreach my $cov_dir (($cov_cln_dir, $cov_mut_dir)) {
    `chmod -R u+w $cov_dir`; 
    foreach my $cov_file (<$cov_dir/*.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`; 
    }
    `chmod -R a-w $cov_dir`; 
}
### END cloned from replay_package ###

open(RESULT, ">$result_file") or die "FATAL ERROR: Couldn't write to $result_file\n"; 
my $cov_head = '', my $det_head = ''; 
for (my $i = 1; $i <= $tst_len; $i++) {
    $cov_head .= " Covered$i"; 
    $det_head .= " Detected$i"; 
}
print RESULT "TstNum$cov_head$det_head\n"; 
open(REPRESULT, $replay_result_file) or die "FATAL ERROR: Couldn't read $replay_result_file\n"; 
$head = <REPRESULT>; 
die "FATAL ERROR: Unknown header in $replay_result_file\n"  if ($head !~ m/^TstNum\s+Covered\s+Detected$/); 
while (<REPRESULT>) {
    chomp; 
    my ($tst_num, $cov, $det) = split; 
    my $err = 0; 
    if (! -e "$tst_dir/$tst_num.tst") {
        print "ERROR: missing $tst_dir/$tst_num.tst\n"; 
        $err = 1; 
    }
    if ($det && ! -e "$orc_cln_dir/$tst_num.orc") {
        print "ERROR: missing $orc_cln_dir/$tst_num.orc\n"; 
        $err = 1; 
    }
    if ($det && ! -e "$orc_mut_dir/$tst_num.orc") {
        print "ERROR: missing $orc_mut_dir/$tst_num.orc\n"; 
        $err = 1; 
    }
    next  if ($err); 
    
    my @cov = coverage_steps($tst_num); 
    my @det = detection_steps($tst_num); 
    if (@cov != $tst_len || @det != $tst_len) {
	print "ERROR: cov size (" . scalar(@cov) . ") or det size (" . scalar(@det) . ") != tst_len ($tst_len) for tst_num=$tst_num\n"; 
    } else {
	for (my $i = 0; $i <= $#cov; $i++) {
	    last  if ($cov[$i]); 
	    if ($det[$i]) {
		$det[$i] = -1; 
	    }
	}
    }

    print RESULT "$tst_num " . join(' ', @cov) . " " . join(' ', @det) . "\n"; 
}
close(REPRESULT); 
close(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`; 


# Returns an array (cov) of coverage values, where cov[i] = 1 (0)
# means that step i+1 of the test case with the given $tst_num did
# (didn't) cover $faulty_line, according to the files in
# $cov_cln_dir. Assumes that lines in the coverage files where the
# number of times covered is 0 have been removed.

sub coverage_steps {
    my $tst_num = shift; 
    my $fault_line_str = $fault_line; 
    if ($fault_in_method) {
	$fault_line_str =~ s/:/ /; 
    } else {
	$fault_line_str =~ s/:.*//; 
    }
    my @cov; 
    for (my $i = 1; $i <= $tst_len - 1; $i++) {
	`grep -l "^$fault_line_str " $cov_cln_dir/$tst_num.txt-$i`; 
	my $err = $? >> 8; 
	if ($err == 0) {
	    push @cov, 1; 
	} else {
	    push @cov, 0; 
	    if ($err == 2) {
		print "ERROR: Couldn't do grep -l \"^$fault_line_str \" $cov_cln_dir/$tst_num.txt-$i\n"; 
	    }
	}
    }
    my $existing_files = ''; 
    foreach my $f (("$cov_cln_dir/$tst_num.txt-$tst_len", "$cov_cln_dir/$tst_num.txt", "$cov_cln_dir/$tst_num.txt-final")) {
	$existing_files .= "$f "  if (-e $f); 
    }
    if ($existing_files =~ m/\S/) {
	`grep -l "^$fault_line_str " $existing_files`; 
	my $err = $? >> 8; 
	if ($err == 0) {
	    push @cov, 1; 
	} else {
	    push @cov, 0; 
	    if ($err == 2) {
		print "ERROR: Couldn't do grep -l \"^$fault_line_str \" $existing_files\n"; 
	    }
	}
    } else {
	push @cov, 0; 
	print "ERROR: None of $cov_cln_dir/$tst_num.txt-$tst_len, $cov_cln_dir/$tst_num.txt, $cov_cln_dir/$tst_num.txt-final exist\n"; 
    }
    return @cov; 
}


# Returns an array (det) of detection values, where det[i] = 1 (0)
# means that step i+1 of the test case with the given $tst_num did
# (didn't) detect $faulty_line, according to the files in $orc_cln_dir
# and $orc_mut_dir. Places the output of oracle-diffing these files in
# $orc_diff_dir.

sub detection_steps {
    my $tst_num = shift; 
    my @det; 
    for (my $i = 0; $i < $tst_len; $i++) {
	push @det, 0; 
    }
    if (-e "$orc_cln_dir/$tst_num.orc" && -e "$orc_mut_dir/$tst_num.orc") {
	`chmod -R u+w $orc_cln_dir $orc_mut_dir`; 
	`perl -p -i $orc_sub_file $orc_cln_dir/$tst_num.orc $orc_mut_dir/$tst_num.orc`;  # in case orc_sub_file has changed since replay_package was run
	die "Couldn't do perl -p -i $orc_sub_file $orc_cln_dir/$tst_num.orc $orc_mut_dir/$tst_num.orc\n"  if ($?); 
	`chmod -R a-w $orc_cln_dir $orc_mut_dir`; 
	`java -cp $JAVACLASSFILES:$JAVACLASSFILES/jdom.jar:$JAVACLASSFILES/jargs.jar oracle.Comparer $ignore_option -e $orc_cln_dir/$tst_num.orc $orc_mut_dir/$tst_num.orc >& $orc_diff_dir/$tst_num.txt`; 
	open(DIFF, "$orc_diff_dir/$tst_num.txt") or die "FATAL ERROR: Couldn't read $orc_diff_dir/$tst_num.txt\n"; 
	my $other_exists = 0, my $step_exists = 0; 
	while (my $line = <DIFF>) {
	    chomp $line; 
	    if ($line =~ m/^STEP: (\d+)$/) {
		my $step = $1; 
		$det[$step - 1] = 1  if ($step <= $tst_len); 
		$step_exists = 1; 
	    } elsif ($line =~ m/\S/) {
		$other_exists = 1; 
	    }
	}
	close(DIFF); 
	if ($other_exists && ! $step_exists) {
	    print "ERROR: Something wrong with $orc_diff_dir/$tst_num.txt\n"; 
	}
    }
    return @det;
}    


sub cleanup {
    `chmod -R a-w $orc_diff_dir $result_file`; 
}