891 lines
20 KiB
Perl
Executable File
891 lines
20 KiB
Perl
Executable File
#!/usr/bin/perl -w
|
|
|
|
use strict;
|
|
use FileHandle;
|
|
use Getopt::Std;
|
|
use IO::File;
|
|
use POSIX qw(strftime);
|
|
|
|
format HEADER =
|
|
|
|
cover_test.pl -f diff.log -d ./ -l output.log -p prev_commit
|
|
Syntax: cover_test.pl -option value
|
|
|
|
-f: the diff log file / Required
|
|
-d: the fundamental dir / optional
|
|
-l: the output / optional
|
|
-p: the prev commit id / optional
|
|
.
|
|
|
|
my $debug = 0;
|
|
|
|
|
|
my ($diff, $directory, $log, $prev_commit);
|
|
my $delta_path = "coverage";
|
|
&do_opt();
|
|
|
|
|
|
if(!defined $prev_commit)
|
|
{
|
|
$prev_commit=`git rev-parse HEAD~1`;
|
|
}
|
|
|
|
my $reg_line = '(.*)\n$';
|
|
my $current_commit=`git rev-parse HEAD~0`;
|
|
my $current_branch=`git rev-parse --abbrev-ref HEAD`;
|
|
|
|
$diff = "diff.log";
|
|
$prev_commit = &ppgrep($prev_commit, $reg_line, 1);
|
|
$current_commit = &ppgrep($current_commit, $reg_line, 1);
|
|
|
|
$prev_commit = $prev_commit->[0];
|
|
$current_commit = $current_commit->[0];
|
|
|
|
system("git config diff.renameLimit 10000;
|
|
git diff $prev_commit $current_commit > $diff");
|
|
|
|
if(!defined $diff)
|
|
{
|
|
&crit_record("pls input diff file");
|
|
}
|
|
|
|
if(!defined $directory)
|
|
{
|
|
$directory =".";
|
|
}
|
|
|
|
if(defined $log)
|
|
{
|
|
print "pls check the execute message in [$delta_path/$log]\n";
|
|
print "pls check the delta result in [$delta_path/delta_coverage.out]\n";
|
|
my $fd =POSIX::open( "$delta_path/$log", &POSIX::O_CREAT | &POSIX::O_WRONLY, 0640);
|
|
POSIX::dup2($fd, 1);
|
|
POSIX::dup2($fd, 2);
|
|
}
|
|
|
|
&record("directory=[$directory]; diff=[$diff];");
|
|
|
|
#interpret the diff file
|
|
|
|
my($hd_diff) = &getFileHandle($diff,"r"); #diff.org file
|
|
|
|
if (!defined $hd_diff)
|
|
{
|
|
&crit_record("diff [$diff] init fail, pls check it!");
|
|
}
|
|
|
|
&record("begin to interpret diff file!");
|
|
|
|
my $reg_diff = 'diff --git [ab]/(.+?)[\s\n]';
|
|
my $reg_add = '^\+(.*)';
|
|
my @reg_old = ('^-');
|
|
my @reg_del = ('^\+') ;
|
|
|
|
|
|
#my @reg_file = ('\.h$','\.cc$','\.c$','\.ic$');
|
|
my @reg_file = ('\.c$', '\.cpp$');
|
|
|
|
my $type_gcno = "gcno";
|
|
my $type_gcov = "gcov";
|
|
my $reg_cnt = '^@@.*?\d*,\d*.*?(\d*),(\d*) @@';
|
|
|
|
|
|
my $reg_gcov_1 = '^-:\s*(\d+):(.*)';
|
|
my $reg_gcov_2 = '^(#####|\d+):\s*(\d+):(.*)';
|
|
my $reg_gcov_3 = '^#####:\s*(\d+):(.*)';
|
|
|
|
my $reg_hgcov_file = '\.h\.gcov';
|
|
my $reg_file_prefix = '(.*)\..*';
|
|
|
|
my $line;
|
|
my %src_file = ();
|
|
my ($ref_raw_line, $raw_line, $key);
|
|
my ($bcnt, $ecnt) =(0,0);
|
|
my $delta =-1;
|
|
my $current =0;
|
|
my $in_block =0;
|
|
|
|
my $result_fd;
|
|
open($result_fd, ">$delta_path/delta_coverage.txt");
|
|
|
|
my $diff_line_num = 0;
|
|
my $no_test_line_num = 0;
|
|
|
|
while($line = $hd_diff->getline())
|
|
{
|
|
# find the file
|
|
$ref_raw_line = &ppgrep($line, $reg_diff, 1);
|
|
if(defined $ref_raw_line)
|
|
{
|
|
$in_block = 0;
|
|
$delta = -1;
|
|
$raw_line = $ref_raw_line->[0];
|
|
$raw_line = "$directory/$raw_line";
|
|
&debug_record("diff file has: $raw_line");
|
|
my @add_lines = ();
|
|
$key = $raw_line;
|
|
$src_file{$key} = \@add_lines;
|
|
|
|
$bcnt = 0;
|
|
$ecnt = 0;
|
|
next;
|
|
}
|
|
|
|
$ref_raw_line = &ppgrep($line, $reg_cnt, 2);
|
|
if(defined $ref_raw_line)
|
|
{
|
|
$in_block = 1;
|
|
$delta = -1;
|
|
my $c1 = $ref_raw_line->[0];
|
|
my $c2 = $ref_raw_line->[1];
|
|
$bcnt = $c1;
|
|
$ecnt = $c1+$c2-1;
|
|
$current = $c1-1;
|
|
print("\tdiff file has: $key: begin: $bcnt end: $ecnt\n");
|
|
next;
|
|
}
|
|
|
|
if ($in_block == 0)
|
|
{
|
|
next;
|
|
}
|
|
my $is_old = &filterLine(\@reg_old, $line);
|
|
if ($is_old == 0)
|
|
{
|
|
next;
|
|
}
|
|
$current = $current + 1;
|
|
|
|
#find the lines with head of '+'
|
|
$ref_raw_line = &ppgrep($line, $reg_add, 1);
|
|
if(defined $ref_raw_line)
|
|
{
|
|
my $new_ref_array = $src_file{$key};
|
|
&update_ecnt_by_bcnt($new_ref_array, $bcnt);
|
|
$raw_line = $ref_raw_line->[0];
|
|
$delta = $delta+1;
|
|
|
|
#del the backspace
|
|
$raw_line = &delbackspace($raw_line);
|
|
if (! defined $raw_line)
|
|
{
|
|
next;
|
|
}
|
|
&debug_record("diff file lines: $raw_line");
|
|
|
|
my $tmp_ref_array = $src_file{$key};
|
|
my @st_line = ($raw_line,$bcnt, $bcnt+$delta);
|
|
push(@$tmp_ref_array, \@st_line);
|
|
next;
|
|
}
|
|
elsif (!defined $ref_raw_line)
|
|
{
|
|
$bcnt = $current+1;
|
|
$delta = -1;
|
|
}
|
|
}
|
|
|
|
#-------------------------------print the currect line scope---------------------------------
|
|
|
|
my $value;
|
|
my $repeat = -1;
|
|
print "\n";
|
|
&record("begin to amend diff file[amend the bcnt, ecnt]!");
|
|
while(($key, $value) = each %src_file)
|
|
{
|
|
$repeat = -1;
|
|
foreach my $ref_correct(@$value)
|
|
{
|
|
my ($line_correct, $bcnt_correct, $ecnt_correct) =@$ref_correct;
|
|
&debug_record("\tline:$line_correct|bcnt=$bcnt_correct|ecnt=$ecnt_correct\n");
|
|
if ($repeat == $bcnt_correct)
|
|
{
|
|
next;
|
|
}
|
|
else
|
|
{
|
|
$repeat =$bcnt_correct;
|
|
print("\tdiff file has: $key: begin: $bcnt_correct end: $ecnt_correct\n");
|
|
}
|
|
}
|
|
}
|
|
print "\n";
|
|
|
|
#-------------------------------filter the not c/c++/h source file---------------------------------
|
|
my @filtered_file = ();
|
|
my @valid_file = ();
|
|
my $all_file_cnt = 0;
|
|
while(($key, $value) = each %src_file)
|
|
{
|
|
$all_file_cnt++;
|
|
|
|
# filter the file
|
|
my $ret = &filterLine(\@reg_file, $key);
|
|
if($ret == 0)
|
|
{
|
|
push(@valid_file, $key);
|
|
next;
|
|
}
|
|
else
|
|
{
|
|
push(@filtered_file, $key);
|
|
}
|
|
}
|
|
|
|
my $novalid_cnt = scalar(@filtered_file);
|
|
my $valid_cnt = $all_file_cnt - $novalid_cnt;
|
|
|
|
&record("The diff log include : [$all_file_cnt\t] files");
|
|
|
|
&record("The valid source file: [$valid_cnt\t]; listing as below:\n");
|
|
|
|
my $add_lines_cnt;
|
|
|
|
foreach my $file(@valid_file)
|
|
{
|
|
$value = $src_file{$file};
|
|
$add_lines_cnt =scalar(@$value);
|
|
print "\t\t\t lines:[$add_lines_cnt\t];file:[$file]\n";
|
|
}
|
|
|
|
&record("The filtered file: [$novalid_cnt\t]; listing as below:\n");
|
|
|
|
foreach my $file(@filtered_file)
|
|
{
|
|
$value = $src_file{$file};
|
|
$add_lines_cnt =scalar(@$value);
|
|
print "\t\t\t lines:[$add_lines_cnt\t];file:[$file]\n";
|
|
}
|
|
|
|
#---------------------------------begin to check-----------------------------------------------------
|
|
|
|
&record("begin to check files:");
|
|
|
|
my ($file_name, $file_gcno, $file_name_gcno, $file_gcov, $file_name_gcov, $file_path);
|
|
|
|
print $result_fd "==============Delta Code Coverage Start==============\n";
|
|
|
|
print $result_fd "current_branch = $current_branch\n";
|
|
print $result_fd "prev_commit = $prev_commit\ncurrent_commit = $current_commit\n\n";
|
|
|
|
my $total_test_line_num = 0;
|
|
my $total_diff_line_num = 0;
|
|
my $total_no_cover_line_num = 0;
|
|
|
|
my @no_compile_files = ();
|
|
my @no_test_files = ();
|
|
|
|
my $reg_no_test_directory = '^./src/test/';
|
|
my $no_test_directory;
|
|
|
|
foreach my $file(@valid_file)
|
|
{
|
|
print("\nfile: $file------------------------------------------\n");
|
|
|
|
if (-e $file) #diff file
|
|
{
|
|
print $result_fd "file [$file] begin--------------------\n";
|
|
$file_name = &getFileName($file);
|
|
|
|
#----------------debug
|
|
if( $debug and $file_name ne "mysqld.cc")
|
|
{
|
|
next;
|
|
}
|
|
|
|
#exclude files from "./src/test" directory
|
|
$no_test_directory = &isgrep($file, $reg_no_test_directory);
|
|
if($no_test_directory == 0)
|
|
{
|
|
print $result_fd " INFO: Test files are not included in delta coverage.\n";
|
|
print $result_fd "file [$file] end----------------------\n\n";
|
|
next;
|
|
}
|
|
$file_path = &getFilePath($file);
|
|
$file_name_gcno = &genTargetFileNameFor51($file_name, $type_gcno); #turn *.c.gcno to *.gcno
|
|
$file_gcno = "$file_path/$file_name_gcno";
|
|
|
|
&record("file = [$file]; gcno = [$file_gcno]");
|
|
|
|
if(!defined $file_gcno or ! -e $file_gcno)
|
|
{
|
|
&warn_record("file [$file_name_gcno] is not compiled.");
|
|
print $result_fd " WARNING: file [$file] is not compiled!\n";
|
|
push(@no_compile_files, $file);
|
|
}
|
|
else
|
|
{
|
|
#gen the gcov file
|
|
$file_name_gcov = &genTargetFileName($file_name, $type_gcov);
|
|
$file_gcov = "$directory/$delta_path/$file_name_gcov";
|
|
|
|
my $ret = &gengcov($file_name, $file_name_gcno, $file_name_gcov, $file_path, $directory);
|
|
if ($ret != 0)
|
|
{
|
|
&warn_record("file [$file_name_gcno] is not tested!");
|
|
print $result_fd " WARNING: file [$file] is not tested!\n";
|
|
push(@no_test_files, $file);
|
|
}
|
|
else
|
|
{
|
|
&record("......begin to scan gcov file [$file_gcov]......");
|
|
my $ref_diff_lines = $src_file{$file};
|
|
|
|
print $result_fd "Test Situation:\n";
|
|
&compare($ref_diff_lines, $file_gcov);
|
|
|
|
my $test_line_num = $diff_line_num - $no_test_line_num;
|
|
print $result_fd "Test Rate: $test_line_num / $diff_line_num\n";
|
|
$total_test_line_num = $total_test_line_num + $test_line_num;
|
|
$total_diff_line_num = $total_diff_line_num + $diff_line_num;
|
|
}
|
|
}
|
|
print $result_fd "file [$file] end----------------------\n\n";
|
|
}
|
|
else
|
|
{
|
|
&warn_record("file [$file] not exists!");
|
|
print $result_fd "file [$file] does not exist";
|
|
}
|
|
|
|
}
|
|
|
|
print $result_fd "\n---------------------------------------\n";
|
|
print $result_fd "Total Test Situation:\n";
|
|
print $result_fd "No Cover Lines: $total_no_cover_line_num\n";
|
|
|
|
my $no_compile_num = @no_compile_files;
|
|
my $no_test_num = @no_test_files;
|
|
|
|
print $result_fd "No Compile Files: $no_compile_num\n";
|
|
foreach my $file(@no_compile_files)
|
|
{
|
|
print $result_fd " $file\n";
|
|
}
|
|
|
|
print $result_fd "No Test Files: $no_test_num\n";
|
|
foreach my $file(@no_test_files)
|
|
{
|
|
print $result_fd " $file\n";
|
|
}
|
|
|
|
if ($total_diff_line_num == 0)
|
|
{
|
|
print $result_fd "No different line in .c file\n";
|
|
}
|
|
else
|
|
{
|
|
my $test_rate = ($total_test_line_num / $total_diff_line_num) * 100;
|
|
print $result_fd "Test Rate: $total_test_line_num / $total_diff_line_num = $test_rate%\n";
|
|
}
|
|
|
|
#------------------------------------------------------------
|
|
#correct the end line number
|
|
#------------------------------------------------------------
|
|
sub update_ecnt_by_bcnt()
|
|
{
|
|
my($ref_array, $bcnt) = @_;
|
|
if(defined $ref_array)
|
|
{
|
|
foreach my $ref(@$ref_array)
|
|
{
|
|
my($tmp_line, $tmp_bcnt, $tmp_ecnt) =@$ref;
|
|
if ($tmp_bcnt == $bcnt)
|
|
{
|
|
@$ref =($tmp_line, $tmp_bcnt, $tmp_ecnt+1);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
#------------------------------------------------------------
|
|
#find the file
|
|
#------------------------------------------------------------
|
|
sub find_gcno(){
|
|
my($file_name_gcno, $dir) =@_;
|
|
my @result = `find $dir -name '$file_name_gcno'`;
|
|
if(defined $result[0]){
|
|
chomp($result[0]);
|
|
return $result[0];
|
|
}
|
|
else{
|
|
|
|
return undef;
|
|
}
|
|
}
|
|
|
|
#----------------------------------------------------
|
|
#append the file type
|
|
#----------------------------------------------------
|
|
sub genTargetFileName(){
|
|
my($file_name, $type) = @_;
|
|
my $type_file = "$file_name.$type";
|
|
return $type_file;
|
|
}
|
|
|
|
|
|
sub genTargetFileNameFor51(){
|
|
my($file_name, $type) = @_;
|
|
my $ref_file_prefix = &ppgrep($file_name, $reg_file_prefix, 1);
|
|
my $file_prefix = $ref_file_prefix->[0];
|
|
return "$file_prefix.$type";
|
|
|
|
}
|
|
#-----------------------------------------------------
|
|
#get the filename from string
|
|
#-----------------------------------------------------
|
|
sub getFileName(){
|
|
my($full_path) = @_;
|
|
my $file_name;
|
|
if($full_path =~ /.*\/(.*?)$/){
|
|
$file_name = $1;
|
|
}
|
|
else{
|
|
$file_name = $full_path;
|
|
}
|
|
return $file_name;
|
|
}
|
|
|
|
#-----------------------------------------------------
|
|
# POLAR: get the file path from string
|
|
#-----------------------------------------------------
|
|
sub getFilePath()
|
|
{
|
|
my($full_path) = @_;
|
|
my $file_path;
|
|
if($full_path =~ /(.*)\/(.*?)$/)
|
|
{
|
|
$file_path = $1;
|
|
}
|
|
else
|
|
{
|
|
$file_path = $full_path;
|
|
}
|
|
return $file_path;
|
|
}
|
|
#------------------------------------------------------------------------
|
|
#
|
|
#------------------------------------------------------------------------
|
|
sub compare()
|
|
{
|
|
my ($ref_diff_lines, $file_gcov) =@_;
|
|
|
|
my $hd_gcov = &getFileHandle($file_gcov, "r");
|
|
my $reg = "^#####:";
|
|
|
|
my $reg_no_cover = '\/\*no cover line\*\/$'; #"/*no cover line*/"
|
|
my $reg_no_cover_begin = '\/\*no cover begin\*\/$'; #"/*no cover begin*/"
|
|
my $reg_no_cover_end = '\/\*no cover end\*\/$'; #"/*no cover end*/"
|
|
|
|
my $no_cover_line_num = 0;
|
|
|
|
my $in_no_cover = 0;
|
|
my $after_no_cover_line = 0;
|
|
|
|
my $bcnt;
|
|
my $ecnt;
|
|
my $sr_cnt;
|
|
my $cov_ret;
|
|
|
|
my $temp_ret;
|
|
my $temp_line;
|
|
my $ret;
|
|
|
|
#print output to report.txt
|
|
|
|
$diff_line_num = 0;
|
|
$no_test_line_num = 0;
|
|
while(my $line = $hd_gcov->getline())
|
|
{
|
|
my $parse_line = $line;
|
|
#&debug_record("the gcno lines: $parse_line");
|
|
|
|
#step 1: del backspace
|
|
$parse_line = &delbackspace($parse_line);
|
|
if(!defined $parse_line)
|
|
{
|
|
next;
|
|
}
|
|
|
|
# "/*no cover line*/"
|
|
$cov_ret = &isgrep($parse_line, $reg_no_cover);
|
|
if($cov_ret == 0) #find "/*no cover line*/"
|
|
{
|
|
$after_no_cover_line = 1;
|
|
next;
|
|
}
|
|
|
|
# "/*no cover begin*/"
|
|
$cov_ret = &isgrep($parse_line, $reg_no_cover_begin);
|
|
if( $cov_ret == 0 and $in_no_cover == 0)
|
|
{
|
|
$in_no_cover = 1;
|
|
next;
|
|
}
|
|
|
|
# "/*no cover end*/"
|
|
$cov_ret = &isgrep($parse_line, $reg_no_cover_end);
|
|
if ($cov_ret == 0 and $in_no_cover == 1)
|
|
{
|
|
$in_no_cover = 0;
|
|
next;
|
|
}
|
|
|
|
#step 2: not grep -
|
|
$ret = &isgrep($parse_line, $reg_gcov_1); #return 0 if match '-'
|
|
if($ret == 0)
|
|
{
|
|
next;
|
|
}
|
|
|
|
if($in_no_cover == 1 or $after_no_cover_line == 1) #(between "/*no cover begin*/" and "/*no cover end*/") or (after "/*no cover line*/)"
|
|
{
|
|
$after_no_cover_line = 0;
|
|
$no_cover_line_num++;
|
|
next;
|
|
}
|
|
|
|
$temp_line = $parse_line;
|
|
$parse_line = &ppgrep($parse_line, $reg_gcov_2, 3);
|
|
if (!defined $parse_line)
|
|
{
|
|
next;
|
|
}
|
|
|
|
$sr_cnt = $parse_line->[1]; #line number
|
|
$parse_line = $parse_line->[2]; #statement
|
|
|
|
#step 3: del backspace
|
|
$parse_line = &delbackspace($parse_line);
|
|
if(!defined $parse_line)
|
|
{
|
|
next;
|
|
}
|
|
|
|
#step 4: del the no meaning line
|
|
$ret = &ismeaning($parse_line);
|
|
if($ret != 0)
|
|
{
|
|
next;
|
|
}
|
|
|
|
$temp_ret = &isgrep($temp_line, $reg_gcov_3); #retrun 0 if match #####
|
|
|
|
foreach my $diff_line(@$ref_diff_lines)
|
|
{
|
|
$ret = &isMatchStr($parse_line, $sr_cnt, $diff_line);
|
|
&debug_record("begin: $line end: $diff_line : result is $ret");
|
|
|
|
my $string;
|
|
if($ret == 0)
|
|
{
|
|
|
|
$diff_line_num = $diff_line_num + 1;
|
|
print "$line";
|
|
print $result_fd "$line";
|
|
|
|
if ($temp_ret == 0)
|
|
{
|
|
#print $result_fd "$line";
|
|
$no_test_line_num = $no_test_line_num + 1;
|
|
}
|
|
last;
|
|
}
|
|
}
|
|
}
|
|
|
|
if($no_cover_line_num > 0)
|
|
{
|
|
$total_no_cover_line_num = $total_no_cover_line_num + $no_cover_line_num;
|
|
|
|
my $str2;
|
|
my $str1 = "INFO: Filter the no cover lines: $no_cover_line_num";
|
|
if($in_no_cover == 1 or $after_no_cover_line == 1)
|
|
{
|
|
$str2 = "FATAL: Some 'no cover hint' don't match, pls check!!!";
|
|
}
|
|
else
|
|
{
|
|
$str2 = "INFO: All 'no cover hint' match correctly";
|
|
}
|
|
&sp_warn_record($str1, $str2);
|
|
|
|
if($in_no_cover == 1 or $after_no_cover_line == 1)
|
|
{
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
#------------------------------------------------------------------
|
|
#judge it is meaning line
|
|
#------------------------------------------------------------------
|
|
sub ismeaning(){
|
|
my($str) = @_;
|
|
if( $str =~ /[0-9]|[a-z]|[A-Z]/){
|
|
return 0;
|
|
}
|
|
else{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
#------------------------------------------------------------------
|
|
#
|
|
#------------------------------------------------------------------
|
|
sub isMatchStr(){
|
|
my($parse_line, $sr_cnt, $diff_line) = @_;
|
|
my ($bcnt, $ecnt);
|
|
($diff_line, $bcnt, $ecnt) = @$diff_line;
|
|
my $ret = &isfullstr($parse_line, $diff_line);
|
|
if ($ret == 0){
|
|
if($bcnt != 0 or $ecnt != 0){
|
|
if( $sr_cnt >= $bcnt and $sr_cnt <= $ecnt){
|
|
return 0;
|
|
}
|
|
else{
|
|
return 1;
|
|
}
|
|
}
|
|
else{
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
#------------------------------------------------------------------
|
|
#
|
|
#------------------------------------------------------------------
|
|
sub issubstr(){
|
|
my($full, $str) = @_;
|
|
my $pos = index($full, $str);
|
|
if( defined $pos and $pos >= 0){
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
#------------------------------------------------------------------
|
|
#
|
|
#------------------------------------------------------------------
|
|
sub isfullstr(){
|
|
my($full, $str) = @_;
|
|
if ($full eq $str){
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
#------------------------------------------------------------------
|
|
#generate the gcov file
|
|
#------------------------------------------------------------------
|
|
sub gengcov()
|
|
{
|
|
my ($file_name, $file_name_gcno, $file_name_gcov, $file_path, $directory) = @_;
|
|
|
|
my $file_gcno = "$file_path/$file_name_gcno";
|
|
|
|
if(!defined $file_gcno)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
# POLAR
|
|
my $ret1 = system("cd $file_path;
|
|
gcov $file_name -o $file_name_gcno >/dev/null"); #return 0 if success
|
|
|
|
my $ret2 = system("mv $file_path/$file_name_gcov $directory/$delta_path/$file_name_gcov");
|
|
|
|
$ret1 = $ret1 >> 8;
|
|
$ret2 = $ret2 >> 8;
|
|
if($ret1 == 0 && $ret2 == 0)
|
|
{
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
#-------------------------------------------------------
|
|
#replace the file type
|
|
#-------------------------------------------------------
|
|
sub replaceFileType(){
|
|
my ($str, $target) = @_;
|
|
my $newstr = $str;
|
|
if($str =~ /(.*)\..*?$/){
|
|
return "$1.$target";
|
|
}
|
|
return undef;
|
|
}
|
|
|
|
#-------------------------------------------------------
|
|
#truncate the backspace on the head and tail
|
|
#-------------------------------------------------------
|
|
sub delbackspace(){
|
|
my($str) =@_;
|
|
if( !defined $str or $str eq ""){
|
|
return undef;
|
|
}
|
|
$str =~s/^\s+//g;
|
|
$str =~s/\$\s+//g;
|
|
if ($str eq ""){
|
|
return undef;
|
|
}
|
|
return $str;
|
|
}
|
|
|
|
#------------------------------------------------------
|
|
#judge the str is in array
|
|
#------------------------------------------------------
|
|
sub isStrInArray(){
|
|
my (@array, $line) =@_;
|
|
foreach my $tmp(@array){
|
|
if($line eq $tmp){
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
#-------------------------------------------------------
|
|
#justify is success to grep the line according to regex
|
|
#-------------------------------------------------------
|
|
sub isgrep()
|
|
{
|
|
my ($line, $reg) =@_;
|
|
if($line =~ /$reg/)
|
|
{
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
|
|
#------------------------------------------------------
|
|
#grep the result
|
|
#------------------------------------------------------
|
|
sub ppgrep()
|
|
{
|
|
my($line, $reg, $cnt) = @_;
|
|
my @ret = ();
|
|
if($line =~ /$reg/i)
|
|
{
|
|
if ($cnt >=1){
|
|
push(@ret, $1);
|
|
}
|
|
if ($cnt >=2){
|
|
push(@ret, $2);
|
|
}
|
|
if ($cnt >=3){
|
|
push(@ret, $3);
|
|
}
|
|
if ($cnt >=4){
|
|
return undef;
|
|
}
|
|
return \@ret;
|
|
}
|
|
else
|
|
{
|
|
return undef;
|
|
}
|
|
}
|
|
|
|
#----------------------------------------------------------
|
|
#filter the lines according to reg array
|
|
#----------------------------------------------------------
|
|
sub filterLine(){
|
|
my($ref_reg, $line) = @_;
|
|
my @arr_filter = @$ref_reg;
|
|
foreach my $reg(@arr_filter){
|
|
my $ret =&isgrep($line,$reg);
|
|
if( $ret == 0){
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
#------------------------------------------
|
|
#record the information
|
|
#------------------------------------------
|
|
sub record(){
|
|
my($string) = @_;
|
|
my $current_time = strftime("%Y-%m-%d %H:%M:%S", localtime(time));
|
|
print("$current_time: info: $string\n");
|
|
}
|
|
|
|
#------------------------------------------
|
|
#record the crit
|
|
#------------------------------------------
|
|
sub crit_record(){
|
|
my($string) = @_;
|
|
my $current_time = strftime("%Y-%m-%d %H:%M:%S", localtime(time));
|
|
print("$current_time: crit: $string\n");
|
|
exit(1);
|
|
}
|
|
|
|
#------------------------------------------
|
|
#record the crit
|
|
#------------------------------------------
|
|
sub debug_record(){
|
|
my($string) = @_;
|
|
if( $debug ==1){
|
|
my $current_time = strftime("%Y-%m-%d %H:%M:%S", localtime(time));
|
|
print("$current_time: debug: $string\n");
|
|
}
|
|
}
|
|
#------------------------------------------
|
|
#record the warn
|
|
#------------------------------------------
|
|
sub warn_record(){
|
|
my($string) = @_;
|
|
my $current_time = strftime("%Y-%m-%d %H:%M:%S", localtime(time));
|
|
print("$current_time: warn: $string\n");
|
|
}
|
|
|
|
|
|
sub sp_warn_record(){
|
|
my($str1, $str2) = @_;
|
|
|
|
print $result_fd " $str1\n";
|
|
print $result_fd " $str2\n";
|
|
}
|
|
#---------------------------------------------------------------------
|
|
#init the file handle
|
|
#---------------------------------------------------------------------
|
|
sub getFileHandle{
|
|
my($file, $mode) = @_;
|
|
my ($hd);
|
|
$hd = new FileHandle($file,"$mode");
|
|
return $hd;
|
|
}
|
|
|
|
|
|
#---------------------------------------------------------------------------------
|
|
#split the input parameters
|
|
#---------------------------------------------------------------------------------
|
|
sub do_opt{
|
|
use vars '$opt_h','$opt_H','$opt_f','$opt_d','$opt_l','$opt_p';
|
|
my $returncode = getopts('hH:f:d:l:p:');
|
|
&do_help() if(defined $opt_h or defined $opt_H or $returncode!=1);
|
|
$diff = $opt_f if(defined $opt_f);
|
|
$directory = $opt_d if(defined $opt_d);
|
|
$log = $opt_l if(defined $opt_l);
|
|
$prev_commit = $opt_p if(defined $opt_p);
|
|
$prev_commit = "$prev_commit\n";
|
|
}
|
|
#----------------------------------------------------------------------------------
|
|
#give help information and exit;
|
|
#---------------------------------------------------------------------------------
|
|
sub do_help{
|
|
$~ = "HEADER";
|
|
write;
|
|
exit(1);
|
|
}
|