Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
[tesh] kill unused variables
[simgrid.git] / tools / tesh / tesh.pl
1 #! /usr/bin/env perl
2
3 # Copyright (c) 2012-2014. The SimGrid Team.
4 # All rights reserved.
5
6 # This program is free software; you can redistribute it and/or modify it
7 # under the terms of the license (GNU LGPL) which comes with this package.
8 eval 'exec perl -S $0 ${1+"$@"}'
9   if $running_under_some_shell;
10
11 =encoding UTF-8
12
13 =head1 NAME
14
15 tesh -- testing shell
16
17 =head1 SYNOPSIS
18
19 B<tesh> [I<options>] I<tesh_file>
20
21 =cut
22 my($bindir)=".";
23 my($srcdir)=".";
24 my($timeout)=0;
25 my($time_to_wait)=0;
26 my $path = $0;
27 my $enable_coverage=0;
28 my $diff_tool=0;
29 my $diff_tool_tmp_fh=0;
30 my $diff_tool_tmp_filename=0;
31 my $sort_prefix = -1;
32 my $tesh_file;
33 my $tesh_name;
34 my $error=0;
35 my $exitcode=0;
36 my @bg_cmds;
37 my (%environ);
38 $SIG{'PIPE'} = 'IGNORE';
39 $path =~ s|[^/]*$||;
40 push @INC,$path;
41
42 use Getopt::Long qw(GetOptions);
43 use strict;
44 use Term::ANSIColor;
45 use Text::ParseWords;
46 use IPC::Open3;
47 use IO::File;
48 use English;
49
50 ## 
51 ## Portability bits for windows
52 ##
53
54 use constant RUNNING_ON_WINDOWS => ($^O =~ /^(?:mswin|dos|os2)/oi);
55 use POSIX qw(:sys_wait_h WIFEXITED WIFSIGNALED WIFSTOPPED WEXITSTATUS WTERMSIG WSTOPSIG
56              :signal_h SIGINT SIGTERM SIGKILL SIGABRT SIGSEGV);
57 # These are not implemented on windows
58 BEGIN {
59     if (RUNNING_ON_WINDOWS) {
60         *WIFEXITED   = sub { not $_[0] & 127 };
61         *WEXITSTATUS = sub { $_[0] >> 8 };
62         *WIFSIGNALED = sub { ($_[0] & 127) && ($_[0] & 127 != 127) };
63         *WTERMSIG    = sub { $_[0] & 127 };
64     }
65 }
66
67
68 ##
69 ## Command line option handling
70 ##
71
72 if ($ARGV[0] eq "--internal-killer-process") {
73     # We fork+exec a waiter process in charge of killing the command after timeout
74     # If the command stops earlier, that's fine: the killer sends a signal to an already stopped process, fails, and quits. 
75     #    Nobody cares about the killer issues. 
76     #    The only problem could arise if another process is given the same PID than cmd. We bet it won't happen :)
77     my $time_to_wait = $ARGV[1];
78     my $pid = $ARGV[2];
79     sleep $time_to_wait;
80     kill('TERM', $pid);
81     sleep 1;
82     kill('KILL', $pid);
83     exit $time_to_wait;
84 }
85
86
87 sub var_subst {
88     my ($text, $name, $value) = @_;
89     if ($value) {
90         $text =~ s/\${$name(?::[=-][^}]*)?}/$value/g;
91         $text =~ s/\$$name(\W|$)/$value$1/g;
92     }
93     else {
94         $text =~ s/\${$name:=([^}]*)}/$1/g;
95         $text =~ s/\${$name}//g;
96         $text =~ s/\$$name(\W|$)/$1/g;
97     }
98     return $text;
99 }
100
101 # option handling helper subs
102 sub cd_cmd {
103     my $directory=$_[1];
104     my $failure=1;
105     if (-e $directory && -d $directory) {
106         chdir("$directory");
107         print "[Tesh/INFO] change directory to $directory\n";
108         $failure=0;
109     } elsif (-e $directory) {
110         print "Cannot change directory to '$directory': it is not a directory\n";
111     } else {
112         print "Chdir to $directory failed: No such file or directory\n";
113     }
114     if($failure==1){
115         $error=1;
116         $exitcode=4;
117         print "Test suite `$tesh_file': NOK (system error)\n";
118         exit 4;
119     }
120 }
121
122 sub setenv_cmd {
123   my($var,$ctn);
124   if ($_[0] =~ /^(.*)=(.*)$/) {
125     ($var,$ctn)=($1,$2);
126   }elsif ($_[1] =~ /^(.*)=(.*)$/) {
127     ($var,$ctn)=($1,$2);
128   } else {
129       die "[Tesh/CRITICAL] Malformed argument to setenv: expected 'name=value' but got '$_[1]'\n";
130   }
131
132   print "[Tesh/INFO] setenv $var=$ctn\n";
133   $environ{$var} = $ctn;
134 }
135
136 # Main option parsing sub
137
138 sub get_options {
139   # remove the tesh file from the ARGV used
140   my @ARGV = @_;
141   $tesh_file = pop @ARGV;
142
143   # temporary arrays for GetOption
144   my @cfg;
145   my $log; # ignored
146
147
148   my %opt = (
149     "help"  => 0,
150     "debug"   => 0,
151     );
152
153   Getopt::Long::config('bundling', 'no_getopt_compat', 'no_auto_abbrev');
154
155   GetOptions(
156     'help|h'   => \$opt{'help'},
157
158     'debug|d'  => \$opt{"debug"},
159
160     'difftool=s' => \$diff_tool,
161
162     'cd=s'     => \&cd_cmd,
163     'timeout=s'  => \$opt{'timeout'},
164     'setenv=s'   => \&setenv_cmd,
165     'cfg=s'    => \@cfg,
166     'log=s'    => \$log,
167     'enable-coverage+'  => \$enable_coverage,
168     );
169
170   if($enable_coverage){
171     print "Enable coverage\n";
172   }
173
174   if($diff_tool){
175     use File::Temp qw/ tempfile /;
176     ($diff_tool_tmp_fh, $diff_tool_tmp_filename) = tempfile();
177     print "New tesh: $diff_tool_tmp_filename\n";
178   }
179
180   unless($tesh_file=~/(.*)\.tesh/){
181     $tesh_file="(stdin)";
182     $tesh_name="(stdin)";
183     print "Test suite from stdin\n";
184   }else{
185     $tesh_name=$1;
186     print "Test suite `$tesh_name'\n";
187   }
188
189   foreach (@cfg) {
190     $opt{'cfg'} .= " --cfg=$_";
191   }
192   return %opt;
193 }
194
195 my %opts = get_options(@ARGV);
196
197 ##
198 ## File parsing
199 ##
200 my($return)=-1;
201 my($forked);
202 my($config)="";
203 my(@buffer_tesh)=();
204
205 ###########################################################################
206
207 sub exit_status {
208     my $status = shift;
209     if (WIFEXITED($status)) {
210         $exitcode=WEXITSTATUS($status)+40;
211         return "returned code ".WEXITSTATUS($status);
212     } elsif (WIFSIGNALED($status)) {
213         my $code;
214         if (WTERMSIG($status) == SIGINT){$code="SIGINT"; }
215         elsif  (WTERMSIG($status) == SIGTERM) {$code="SIGTERM"; }
216         elsif  (WTERMSIG($status) == SIGKILL) {$code= "SIGKILL"; }
217         elsif  (WTERMSIG($status) == SIGABRT) {$code="SIGABRT"; }
218         elsif  (WTERMSIG($status) == SIGSEGV) {$code="SIGSEGV" ;}
219         $exitcode=WTERMSIG($status)+4;
220         return "got signal $code";
221     }
222     return "Unparsable status. Is the process stopped?";
223 }
224
225 sub exec_cmd {
226   my %cmd = %{$_[0]};
227   if ($opts{'debug'}) {
228     print "IN BEGIN\n";
229     map {print "  $_"} @{$cmd{'in'}};
230     print "IN END\n";
231     print "OUT BEGIN\n";
232     map {print "  $_"} @{$cmd{'out'}};
233     print "OUT END\n";
234     print "CMD: $cmd{'cmd'}\n";
235   }
236
237   # cleanup the command line
238   if(RUNNING_ON_WINDOWS) {
239       var_subst($cmd{'cmd'}, "EXEEXT", ".exe");
240   } else {
241       var_subst($cmd{'cmd'}, "EXEEXT", "");
242   }
243
244   # substitute environ variables
245   foreach my $key (keys %environ) {
246       $cmd{'cmd'} = var_subst($cmd{'cmd'}, $key, $environ{$key});
247   }
248   # substitute remaining variables, if any
249   while ($cmd{'cmd'} =~ /\${(\w+)(?::[=-][^}]*)?}/) {
250       $cmd{'cmd'} = var_subst($cmd{'cmd'}, $1, "");
251   }
252   while ($cmd{'cmd'} =~ /\$(\w+)/) {
253       $cmd{'cmd'} = var_subst($cmd{'cmd'}, $1, "");
254   }
255
256   # add cfg options
257   $cmd{'cmd'} .= " $opts{'cfg'}" if (defined($opts{'cfg'}) && length($opts{'cfg'}));
258
259   # final cleanup
260   $cmd{'cmd'} =~ s/^\s+//;
261   $cmd{'cmd'} =~ s/\s+$//;
262
263   print "[$tesh_name:$cmd{'line'}] $cmd{'cmd'}\n" ;
264
265   ###
266   # exec the command line
267   ###  $line =~ s/\r//g;
268
269   $cmd{'got'} = IO::File->new_tmpfile;
270   $cmd{'got'}->autoflush(1);
271   local *E = $cmd{'got'};
272   $cmd{'pid'} = open3(\*CHILD_IN,  ">&E",  ">&E",
273                       quotewords('\s+', 0, $cmd{'cmd'}));
274
275   # push all provided input to executing child
276   map { print CHILD_IN "$_\n"; }  @{$cmd{'in'}};
277   close CHILD_IN;
278
279   # if timeout specified, fork and kill executing child at the end of timeout
280   if (not $cmd{'background'} and (defined($cmd{'timeout'}) or defined($opts{'timeout'}))){
281     $time_to_wait= defined($cmd{'timeout'}) ? $cmd{'timeout'} : $opts{'timeout'};
282     $forked = fork();
283     $timeout=-1;
284     die "fork() failed: $!" unless defined $forked;
285     if ( $forked == 0 ) { # child
286         exec("$PROGRAM_NAME --internal-killer-process $time_to_wait $cmd{'pid'}");
287     }
288   }
289
290   # Cleanup the executing child, and kill the timeouter brother on need
291   $cmd{'return'} = 0 unless defined($cmd{'return'});
292   if ($cmd{'background'} != 1) {
293     waitpid ($cmd{'pid'}, 0);
294     $cmd{'gotret'} = exit_status($?);
295     parse_out(\%cmd);
296   } else {
297     # & commands, which will be handled at the end
298     push @bg_cmds, \%cmd;
299   }
300 }
301
302
303 sub parse_out {
304   my %cmd = %{$_[0]};
305   my $gotret=$cmd{'gotret'};
306
307   my $wantret;
308
309   if(defined($cmd{'expect'}) and ($cmd{'expect'} ne "")){
310     $wantret = "got signal $cmd{'expect'}";
311   }else{
312     $wantret = "returned code ".(defined($cmd{'return'})? $cmd{'return'} : 0);
313   }
314
315   local *got = $cmd{'got'};
316   seek(got,0,0);
317   # pop all output from executing child
318   my @got;
319   while(defined(my $got=<got>)) {
320     $got =~ s/\r//g;
321     chomp $got;
322     print $diff_tool_tmp_fh "> $got\n" if ($diff_tool);
323
324     if (!($enable_coverage and $got=~ /^profiling:/)){
325       push @got, $got;
326     }
327   }
328
329   if ($cmd{'sort'}){
330     # Save the unsorted observed output to report it on error.
331     map { push @{$cmd{'unsorted got'}}, $_ } @got;
332
333     sub mysort{
334         substr($a, 0, $sort_prefix) cmp substr($b, 0, $sort_prefix)
335     }
336     use sort 'stable';
337     if ($sort_prefix>0) {
338         @got = sort mysort @got;
339     } else {
340         @got = sort @got;
341     }       
342     while (@got and $got[0] eq "") {
343       shift @got;
344     }
345
346     # Sort the expected output to make it easier to write for humans
347     if(defined($cmd{'out'})){
348       if ($sort_prefix>0) {
349           @{$cmd{'out'}} = sort mysort @{$cmd{'out'}};
350       } else {
351           @{$cmd{'out'}} = sort @{$cmd{'out'}};
352       }
353       while (@{$cmd{'out'}} and ${$cmd{'out'}}[0] eq "") {
354         shift @{$cmd{'out'}};
355       }
356     }
357   }
358
359   # Did we timeout ? If yes, handle it. If not, kill the forked process.
360
361   if($timeout==-1 and ($gotret eq "got signal SIGTERM" or $gotret eq "got signal SIGKILL")){
362     $gotret="return code 0";
363     $timeout=1;
364     $gotret= "timeout after $time_to_wait sec";
365     $error=1;
366     $exitcode=3;
367     print STDERR "<$cmd{'file'}:$cmd{'line'}> timeouted. Kill the process.\n";
368   }else{
369     $timeout=0;
370   }
371   if($gotret ne $wantret) {
372     $error=1;
373     my $msg = "Test suite `$cmd{'file'}': NOK (<$cmd{'file'}:$cmd{'line'}> $gotret)\n";
374     if ($timeout!=1) {
375         $msg=$msg."Output of <$cmd{'file'}:$cmd{'line'}> so far:\n";
376     }
377     map {$msg .=  "|| $_\n"} @got;
378     if(!@got) {
379         if($timeout==1){
380         print STDERR "<$cmd{'file'}:$cmd{'line'}> No output before timeout\n";
381         }else{
382         $msg .= "||\n";
383         }
384     }
385     $timeout = 0;
386     print STDERR "$msg";
387   }
388
389
390   ###
391   # Check the result of execution
392   ###
393   my $diff;
394   if (defined($cmd{'output display'})){
395     print "[Tesh/INFO] Here is the (ignored) command output:\n";
396     map { print "||$_\n" } @got;
397   }
398   elsif (!defined($cmd{'output ignore'})){
399     $diff = build_diff(\@{$cmd{'out'}}, \@got);
400   }else{
401     print "(ignoring the output of <$cmd{'file'}:$cmd{'line'}> as requested)\n"
402   }
403   if (length $diff) {
404     print "Output of <$cmd{'file'}:$cmd{'line'}> mismatch".($cmd{'sort'}?" (even after sorting)":"").":\n";
405     map { print "$_\n" } split(/\n/,$diff);
406     if ($cmd{'sort'}) {
407         print "WARNING: Both the observed output and expected output were sorted as requested.\n";
408         print "WARNING: Output were only sorted using the $sort_prefix first chars.\n"
409           if ($sort_prefix>0);
410         print "WARNING: Use <! output sort 19> to sort by simulated date and process ID only.\n";
411         # print "----8<---------------  Begin of unprocessed observed output (as it should appear in file):\n";
412         # map {print "> $_\n"} @{$cmd{'unsorted got'}};
413         # print "--------------->8----  End of the unprocessed observed output.\n";
414     }
415
416     print "Test suite `$cmd{'file'}': NOK (<$cmd{'file'}:$cmd{'line'}> output mismatch)\n";
417     $error=1;
418     $exitcode=2;
419   }
420 }
421
422 sub mkfile_cmd {
423   my %cmd = %{$_[0]};
424   my $file = $cmd{'arg'};
425   print "[Tesh/INFO] mkfile $file\n";
426
427   unlink($file);
428   open(FILE,">$file") or die "[Tesh/CRITICAL] Unable to create file $file: $!\n";
429   print FILE join("\n", @{$cmd{'in'}});
430   print FILE "\n" if (scalar @{$cmd{'in'}} > 0);
431   close(FILE);
432 }
433
434 # parse tesh file
435 #my $teshfile=$tesh_file;
436 #$teshfile=~ s{\.[^.]+$}{};
437
438 unless($tesh_file eq "(stdin)"){
439   open TESH_FILE, $tesh_file or die "[Tesh/CRITICAL] Unable to open $tesh_file $!\n";
440 }
441
442 my %cmd; # everything about the next command to run
443 my $line_num=0;
444 my $finished =0;
445 LINE: while (not $finished and not $error) {
446   my $line;
447
448
449   if ($tesh_file ne "(stdin)" and !defined($line=<TESH_FILE>)){
450     $finished=1;
451     next LINE;
452   }elsif ($tesh_file eq "(stdin)" and !defined($line=<>)){
453     $finished=1;
454     next LINE;
455   }
456
457   $line_num++;
458   chomp $line;
459   $line =~ s/\r//g;
460   print "[TESH/debug] $line_num: $line\n" if $opts{'debug'};
461   my $next;
462   # deal with line continuations
463   while ($line =~ /^(.*?)\\$/) {
464     $next=<TESH_FILE>;
465     die "[TESH/CRITICAL] Continued line at end of file\n"
466       unless defined($next);
467     $line_num++;
468     chomp $next;
469     print "[TESH/debug] $line_num: $next\n" if $opts{'debug'};
470     $line = $1.$next;
471   }
472
473   # Push delayed commands on empty lines
474   unless ($line =~ m/^(.)(.*)$/) {
475     if (defined($cmd{'cmd'}))  {
476       exec_cmd(\%cmd);
477       %cmd = ();
478     }
479     print $diff_tool_tmp_fh "$line\n" if ($diff_tool);
480     next LINE;
481   }
482
483   my ($cmd,$arg) = ($1,$2);
484   print $diff_tool_tmp_fh "$line\n" if ($diff_tool and $cmd ne '>');
485   $arg =~ s/^ //g;
486   $arg =~ s/\r//g;
487   $arg =~ s/\\\\/\\/g;
488   # handle the commands
489   if ($cmd =~ /^#/) {    #comment
490   } elsif ($cmd eq '>'){    #expected result line
491     print "[TESH/debug] push expected result\n" if $opts{'debug'};
492     push @{$cmd{'out'}}, $arg;
493
494   } elsif ($cmd eq '<') {    # provided input
495     print "[TESH/debug] push provided input\n" if $opts{'debug'};
496     push @{$cmd{'in'}}, $arg;
497
498   } elsif ($cmd eq 'p') {    # comment
499     print "[$tesh_name:$line_num] $arg\n";
500
501   } elsif ($cmd eq '$') {  # Command
502     # if we have something buffered, run it now
503     if (defined($cmd{'cmd'})) {
504       exec_cmd(\%cmd);
505       %cmd = ();
506     }
507     if ($arg =~ /^\s*mkfile /){      # "mkfile" command line
508       die "[TESH/CRITICAL] Output expected from mkfile command!\n" if scalar @{cmd{'out'}};
509
510       $cmd{'arg'} = $arg;
511       $cmd{'arg'} =~ s/\s*mkfile //;
512       mkfile_cmd(\%cmd);
513       %cmd = ();
514
515     } elsif ($arg =~ /^\s*cd /) {
516       die "[TESH/CRITICAL] Input provided to cd command!\n" if scalar @{cmd{'in'}};
517       die "[TESH/CRITICAL] Output expected from cd command!\n" if scalar @{cmd{'out'}};
518
519       $arg =~ s/^ *cd //;
520       cd_cmd("",$arg);
521       %cmd = ();
522
523     } else { # regular command
524       $cmd{'cmd'} = $arg;
525       $cmd{'file'} = $tesh_file;
526       $cmd{'line'} = $line_num;
527     }
528   }
529   elsif($cmd eq '&'){      # parallel command line
530
531     if (defined($cmd{'cmd'})) {
532       exec_cmd(\%cmd);
533       %cmd = ();
534     }
535     $cmd{'background'} = 1;
536     $cmd{'cmd'} = $arg;
537     $cmd{'file'} = $tesh_file;
538     $cmd{'line'} = $line_num;
539   }
540   elsif($line =~ /^!\s*output sort/){    #output sort
541     if (defined($cmd{'cmd'})) {
542       exec_cmd(\%cmd);
543       %cmd = ();
544     }
545     $cmd{'sort'} = 1;
546     if ($line =~ /^!\s*output sort\s+(\d+)/) {
547         $sort_prefix = $1;
548     }
549   }
550   elsif($line =~ /^!\s*output ignore/){    #output ignore
551     if (defined($cmd{'cmd'})) {
552       exec_cmd(\%cmd);
553       %cmd = ();
554     }
555     $cmd{'output ignore'} = 1;
556   }
557   elsif($line =~ /^!\s*output display/){    #output display
558     if (defined($cmd{'cmd'})) {
559       exec_cmd(\%cmd);
560       %cmd = ();
561     }
562     $cmd{'output display'} = 1;
563   }
564   elsif($line =~ /^!\s*expect signal (\w*)/) {#expect signal SIGABRT
565     if (defined($cmd{'cmd'})) {
566       exec_cmd(\%cmd);
567       %cmd = ();
568     }
569 print "hey\n";
570     $cmd{'expect'} = "$1";
571   }
572   elsif($line =~ /^!\s*expect return/){    #expect return
573     if (defined($cmd{'cmd'})) {
574       exec_cmd(\%cmd);
575       %cmd = ();
576     }
577     $line =~ s/^! expect return //g;
578     $line =~ s/\r//g;
579     $cmd{'return'} = $line;
580   }
581   elsif($line =~ /^!\s*setenv/){    #setenv
582     if (defined($cmd{'cmd'})) {
583       exec_cmd(\%cmd);
584       %cmd = ();
585     }
586     $line =~ s/^! setenv //g;
587     $line =~ s/\r//g;
588     setenv_cmd($line);
589   }
590   elsif($line =~ /^!\s*include/){    #include
591     if (defined($cmd{'cmd'})) {
592       exec_cmd(\%cmd);
593       %cmd = ();
594     }
595     print color("red"), "[Tesh/CRITICAL] need include";
596     print color("reset"), "\n";
597     die;
598   }
599   elsif($line =~ /^!\s*timeout/){    #timeout
600     if (defined($cmd{'cmd'})) {
601       exec_cmd(\%cmd);
602       %cmd = ();
603     }
604     $line =~ s/^! timeout //;
605     $line =~ s/\r//g;
606     $cmd{'timeout'} = $line;
607   } else {
608     die "[TESH/CRITICAL] parse error: $line\n";
609   }
610   if($forked){
611    kill('KILL', $forked);
612    $timeout=0;
613   }
614
615 }
616
617
618
619 # Deal with last command
620 if (defined($cmd{'cmd'})) {
621   exec_cmd(\%cmd);
622   %cmd = ();
623 }
624
625
626 if($forked){
627    kill('KILL', $forked);
628    $timeout=0;
629 }
630
631 foreach(@bg_cmds){
632   my %test=%{$_};
633   waitpid ($test{'pid'}, 0);
634   $test{'gotret'} = exit_status($?);
635   parse_out(\%test);
636 }
637
638 @bg_cmds=();
639
640 if ($diff_tool) {
641   close $diff_tool_tmp_fh;
642   system("$diff_tool $diff_tool_tmp_filename $tesh_file");
643   unlink $diff_tool_tmp_filename;
644 }
645
646 if($error !=0){
647     exit $exitcode;
648 }elsif($tesh_file eq "(stdin)"){
649     print "Test suite from stdin OK\n";
650 }else{
651     print "Test suite `$tesh_name' OK\n";
652 }
653
654 #my (@a,@b);
655 #push @a,"bl1";   push @b,"bl1";
656 #push @a,"bl2";   push @b,"bl2";
657 #push @a,"bl3";   push @b,"bl3";
658 #push @a,"bl4";   push @b,"bl4";
659 #push @a,"bl5";   push @b,"bl5";
660 #push @a,"bl6";   push @b,"bl6";
661 #push @a,"bl7";   push @b,"bl7";
662 ##push @a,"Perl";  push @b,"ruby";
663 #push @a,"END1";   push @b,"END1";
664 #push @a,"END2";   push @b,"END2";
665 #push @a,"END3";   push @b,"END3";
666 #push @a,"END4";   push @b,"END4";
667 #push @a,"END5";   push @b,"END5";
668 #push @a,"END6";   push @b,"END6";
669 #push @a,"END7";   push @b,"END7";
670 #print "Identical:\n". build_diff(\@a,\@b);
671
672 #@a = (); @b =();
673 #push @a,"AZE"; push @b,"EZA";
674 #print "Different:\n".build_diff(\@a,\@b);
675
676 use lib "@CMAKE_BINARY_DIR@/bin" ;
677
678 use Diff qw(diff); # postpone a bit to have time to change INC
679
680 sub build_diff {
681   my $res;
682   my $diff = Diff->new(@_);
683
684   $diff->Base( 1 );   # Return line numbers, not indices
685   my $chunk_count = $diff->Next(-1); # Compute the amount of chuncks
686   return ""   if ($chunk_count == 1 && $diff->Same());
687   $diff->Reset();
688   while(  $diff->Next()  ) {
689     my @same = $diff->Same();
690     if ($diff->Same() ) {
691       if ($diff->Next(0) > 1) { # not first chunk: print 2 first lines
692         $res .= '  '.$same[0]."\n" ;
693         $res .= '  '.$same[1]."\n" if (scalar @same>1);
694       }
695       $res .= "...\n"  if (scalar @same>2);
696 #    $res .= $diff->Next(0)."/$chunk_count\n";
697       if ($diff->Next(0) < $chunk_count) { # not last chunk: print 2 last lines
698         $res .= '  '.$same[scalar @same -2]."\n" if (scalar @same>1);
699         $res .= '  '.$same[scalar @same -1]."\n";
700       }
701     }
702     next if  $diff->Same();
703     map { $res .= "- $_\n" } $diff->Items(1);
704     map { $res .= "+ $_\n" } $diff->Items(2);
705   }
706   return $res;
707 }
708
709