sal/qa/buildall.pl

   1 eval 'exec perl -wS $0 ${1+"$@"}'
   2     if 0;
   3 #
   4 # This file is part of the LibreOffice project.
   5 #
   6 # This Source Code Form is subject to the terms of the Mozilla Public
   7 # License, v. 2.0. If a copy of the MPL was not distributed with this
   8 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
   9 #
  10 # This file incorporates work covered by the following license notice:
  11 #
  12 #   Licensed to the Apache Software Foundation (ASF) under one or more
  13 #   contributor license agreements. See the NOTICE file distributed
  14 #   with this work for additional information regarding copyright
  15 #   ownership. The ASF licenses this file to you under the Apache
  16 #   License, Version 2.0 (the "License"); you may not use this file
  17 #   except in compliance with the License. You may obtain a copy of
  18 #   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  19 #
  20
  21 # #!/usr/bin/perl -w
  22
  23 use strict;
  24 use POSIX;
  25 use Cwd;
  26 use File::Path;
  27 use English;
  28 use Cwd 'chdir';
  29
  30 my $cwd = getcwd();
  31
  32 # Prototypes
  33 sub initEnvironment();
  34 sub main($);
  35 sub checkForKillobj();
  36 sub checkARGVFor($);
  37
  38 my $g_sTempDir = "";
  39 my $FS = "";
  40
  41 my $nGlobalFailures = 0;
  42
  43 my %libraryRunThrough;
  44 my $bBuildAll = 0;
  45
  46 # LLA: this does not exist, ... use a little bit simpler method.
  47 # use File::Temp qw/ :POSIX /;
  48
  49 my $params;
  50 my $param;
  51
  52 if ($#ARGV < 0)
  53 {
  54     $params = "test "; # debug=t TESTOPTADD=\"-boom\"   TESTOPTADD=\"-noerroronexit\"
  55
  56     # my $nNumber = 55;
  57     # my $sLocalParams = $params;
  58     # $sLocalParams =~ s/test\s/test$nNumber /;
  59     # print "Testparams: $sLocalParams\n";
  60     # exit 1;
  61     print "Default ";
  62 }
  63 else
  64 {
  65     # special hack!
  66     if (checkForKillobj() == 1)
  67     {
  68         $params = "killobj";
  69     }
  70     elsif (checkARGVFor("buildall") == 1)
  71     {
  72         $bBuildAll = 1;
  73         $params = "test";
  74     }
  75     else
  76     {
  77         # always run test, but envelope the other in 'TESTOPT="..."'
  78         $params = "test TESTOPT=\"";
  79
  80         foreach $param (@ARGV)
  81         {
  82             $params = $params . " " . $param;
  83         }
  84         $params = $params . "\"";
  85     }
  86     print "User defined ";
  87 }
  88
  89 print "parameters for dmake: $params\n";
  90
  91 initEnvironment();
  92 main($params);
  93
  94 # ------------------------------------------------------------------------------
  95 sub checkARGVFor($)
  96 {
  97     my $sCheckValue = shift;
  98     my $sLocalParam;
  99     my $nBackValue = 0;
 100     foreach $sLocalParam (@ARGV)
 101     {
 102         if ($sLocalParam =~ /^${sCheckValue}$/)
 103         {
 104             $nBackValue = 1;
 105             last;
 106         }
 107     }
 108     return $nBackValue;
 109 }
 110 # ------------------------------------------------------------------------------
 111 sub checkForKillobj()
 112 {
 113     my $sLocalParam;
 114     my $nBackValue = 0;
 115     foreach $sLocalParam (@ARGV)
 116     {
 117         if ($sLocalParam =~ /^killobj$/)
 118         {
 119             $nBackValue = 1;
 120             last;
 121         }
 122     }
 123     return $nBackValue;
 124 }
 125
 126 # ------------------------------------------------------------------------------
 127 sub initEnvironment()
 128 {
 129     my $os = $ENV{OS};
 130     # no error output in forms of message boxes
 131     $ENV{'DISABLE_SAL_DBGBOX'}="t";
 132
 133   SWITCH: {
 134       if ( $os eq "WNT" ) {
 135           $FS             = "\\";
 136           $g_sTempDir         = $ENV{TMP}  ? "$ENV{TMP}${FS}" : "c:${FS}tmp${FS}";
 137           last SWITCH;
 138       }
 139       else {
 140           $FS             = "/";
 141           $g_sTempDir         = $ENV{TMP}  ? "$ENV{TMP}${FS}" : "${FS}tmp${FS}";
 142           last SWITCH;
 143       }
 144       print STDERR "buildall.pl: unknown platform\n";
 145       exit(1);
 146   }
 147 }
 148 # ------------------------------------------------------------------------------
 149
 150 sub trim($)
 151 {
 152     my $oldstr = shift;
 153     $oldstr =~ s/^\s*(.*?)\s*$/$1/;
 154     return $oldstr;
 155 }
 156
 157 # ------------------------------------------------------------------------------
 158 sub getLibName($)
 159 {
 160     my $sFile = shift;
 161     if ($OSNAME eq "linux" || $OSNAME eq "solaris")
 162     {
 163         return "lib" . $sFile . ".so";
 164     }
 165     if ($OSNAME eq "MSWin32")
 166     {
 167         return $sFile . ".dll";
 168     }
 169     return $sFile;
 170 }
 171 # ------------------------------------------------------------------------------
 172 sub giveOutAll($)
 173 {
 174     my $sFailureFile = shift;
 175     local *IN;
 176     if (! open(IN, $sFailureFile))
 177     {
 178         print "ERROR: Can't open output file $sFailureFile\n";
 179         return;
 180     }
 181     my $line;
 182     while ($line = <IN>)
 183     {
 184         chomp($line);
 185         print "$line\n";
 186     }
 187     close(IN);
 188 }
 189 # ------------------------------------------------------------------------------
 190 sub giveOutFailures($$)
 191 {
 192     my $sTest = shift;
 193     my $sFailureFile = shift;
 194
 195     my $bBegin = 0;
 196     my $nFailures = 0;
 197
 198     my $line;
 199     local *IN;
 200     if (! open(IN, $sFailureFile))
 201     {
 202         print "ERROR: Can't open output file $sFailureFile\n";
 203         return;
 204     }
 205
 206     my $bStartUnitTest = 0;
 207     while ($line = <IN>)
 208     {
 209         chomp($line);
 210         if ( $line =~ /^- start unit test/)
 211         {
 212             $bStartUnitTest = 1;
 213         }
 214     }
 215     close(IN);
 216
 217     if ($bStartUnitTest == 0)
 218     {
 219         print "\nFailure: Unit test not started. Maybe compiler error.\n";
 220         giveOutAll($sFailureFile);
 221         $nFailures++;
 222         # exit(1);
 223     }
 224     else
 225     {
 226         open(IN, $sFailureFile);
 227         # check if testshl2 was started
 228         while ($line = <IN>)
 229         {
 230             chomp($line);
 231
 232             # handling of the states
 233             if ( $line =~ /^\# -- BEGIN:/)
 234             {
 235                 $bBegin = 1;
 236             }
 237             elsif ( $line =~ /^\# -- END:/)
 238             {
 239                 $bBegin = 0;
 240             }
 241             else
 242             {
 243                 if ($bBegin == 1)
 244                 {
 245                     print "$line\n";
 246                     $nFailures++;
 247                 }
 248             }
 249         }
 250         close(IN);
 251     }
 252
 253     if ($nFailures > 0)
 254     {
 255         # extra return for a better output
 256         print "\nFailures occurred: $nFailures\n";
 257         print "The whole output can be found in $sFailureFile\n";
 258         print "\n";
 259
 260         # Statistics
 261         $nGlobalFailures += $nFailures;
 262     }
 263 }
 264 # ------------------------------------------------------------------------------
 265 sub printOnLibrary($)
 266 {
 267     my $sTarget = shift;
 268     print "       on library: " . getLibName($sTarget);
 269 }
 270 # ------------------------------------------------------------------------------
 271 sub runASingleTest($$)
 272 {
 273     my $sTarget = shift;
 274     my $params = shift;
 275     my $dmake = "dmake $params";
 276
 277     my $sLogPath = $g_sTempDir . "dmake_out_$$";
 278     mkdir($sLogPath);
 279     my $sLogFile = $sLogPath . "/" . $sTarget . ".out";
 280
 281     # due to the fact, a library name in one project is distinct, we should remember all already run through libraries and
 282     # supress same libraries, if they occur one more.
 283
 284     if (exists $libraryRunThrough{getLibName($sTarget)})
 285     {
 286         # already done
 287         return;
 288     }
 289     printOnLibrary($sTarget);
 290     print "\n";
 291
 292 # redirect tcsh ">&" (stdout, stderr)
 293 # redirect 4nt   ">" (stdout), "2>" (stderr)
 294 # print "OSNAME: $OSNAME\n";
 295 # LLA: redirect check canceled, seems to be not work as I want.
 296 #     my $redirect = "";
 297 #     if ($OSNAME eq "linux" || $OSNAME eq "solaris")
 298 #     {
 299 #         # print "UNIX, linux or solaris\n";
 300 #         $redirect = '>>&!' . $sLogFile;
 301 #     }
 302 #     else
 303 #     {
 304 #         if ($OSNAME eq "MSWin32")
 305 #         {
 306 #             # test
 307 #             $redirect = ">>$sLogFile 2>>$sLogFile";
 308 #         }
 309 #     }
 310 #     print "$dmake $redirect\n";
 311
 312 # LLA: so system does also not work as I imagine
 313 #    system("$dmake $redirect");
 314
 315 # LLA: next check, use open with pipe
 316
 317     local *LOGFILE;
 318     if (! open( LOGFILE, '>' . "$sLogFile"))
 319     {
 320         print "ERROR: can't open logfile: $sLogFile\n";
 321         return;
 322     }
 323
 324     my $line;
 325     local *DMAKEOUTPUT;
 326     if (! open( DMAKEOUTPUT, "$dmake 2>&1 |"))
 327     {
 328         print "ERROR: can't open dmake\n";
 329         return;
 330     }
 331     while ($line = <DMAKEOUTPUT>)
 332     {
 333         chomp($line);
 334         print LOGFILE "$line\n";
 335     }
 336     close(DMAKEOUTPUT);
 337     close(LOGFILE);
 338
 339     giveOutFailures($sTarget, $sLogFile);
 340
 341     $libraryRunThrough{getLibName($sTarget)} = "done";
 342 }
 343
 344 # ------------------------------------------------------------------------------
 345 sub interpretLine($)
 346 {
 347     my $line = shift;
 348
 349     my $path;
 350     my $file;
 351
 352     if ($line =~ /^\#/ || $line =~ /^$/)
 353     {
 354         # remark or empty line
 355     }
 356     else
 357     {
 358         # special format, $file == $path
 359         ($path, $file) = split(/;/, $line);
 360         if (! $file)
 361         {
 362             $file = $path;
 363         }
 364         $file = trim($file);
 365         $path = trim($path);
 366     }
 367     return $path, $file;
 368 }
 369 # ------------------------------------------------------------------------------
 370 sub runTestsOnPath($$$)
 371 {
 372     my $path = shift;
 373     my $file = shift;
 374     my $params = shift;
 375
 376     # empty values
 377     if (!$path || $path eq "")
 378     {
 379         # DBG: print "empty path '$path'\n";
 380         return;
 381     }
 382     if (!$file || $file eq "")
 383     {
 384         # DBG: print "empty file '$file'\n";
 385         return;
 386     }
 387
 388 #   print "File: '$file', Path: '$path'\n";
 389     print "Work in directory: $path\n";
 390     my $newpath = $cwd . $FS . $path;
 391 #   print "chdir to $newpath\n";
 392
 393     my $error = chdir($newpath);
 394     cwd();
 395
 396     # run through the hole makefile.mk and check if SHL<D>TARGET = ... exist, for every target call "dmake test<D>"
 397
 398     local *MAKEFILE_MK;
 399     if (! open(MAKEFILE_MK, "makefile.mk"))
 400     {
 401         print "ERROR: can't open makefile.mk in path: $newpath\n";
 402         print "please check your libs2test.txt file in qa directory.\n";
 403     }
 404     my $line;
 405     my $nNumber;
 406     my $sTarget;
 407     my $sLocalParams;
 408
 409     while($line = <MAKEFILE_MK>)
 410     {
 411         chomp($line);
 412
 413         if ($line =~ /SHL(\d)TARGET=(.*)/)
 414         {
 415             $nNumber = $1;
 416             $sTarget = trim($2);
 417
 418             # DBG: print "test$number is lib: $target\n";
 419             $sLocalParams = $params . " ";                  # append a whitespace, so we can check if 'test' exist without additional digits
 420             $sLocalParams =~ s/test\s/test$nNumber/;
 421             # DBG: print "$sLocalParams\n";
 422             if ($bBuildAll == 1 ||
 423                 $file eq $sTarget)
 424             {
 425                 # print "runASingleTest on Target: $sTarget 'dmake $sLocalParams'\n";
 426                 runASingleTest($sTarget, $sLocalParams);
 427             }
 428             else
 429             {
 430                 # printOnLibrary($sTarget);
 431                 # print " suppressed, not in libs2test.txt\n";
 432             }
 433         }
 434     }
 435     close(MAKEFILE_MK);
 436 }
 437
 438 # ------------------------------------------------------------------------------
 439
 440 sub main($)
 441 {
 442     my $params = shift;
 443 #    my $sLogFile = shift;     # "buildall_$$.out";
 444     local *LIBS2TEST;
 445     my $filename = "libs2test.txt";
 446     my $line;
 447
 448     open(LIBS2TEST, $filename) || die "can't open $filename\n";
 449
 450     while($line = <LIBS2TEST>)
 451     {
 452         chomp($line);
 453         # DOS Hack grrrr...
 454         while ($line =~ /
 455 $/)
 456         {
 457             $line = substr($line, 0, -1);
 458         }
 459
 460         # print "$line\n";
 461         my $path;
 462         my $file;
 463         ($path, $file) = interpretLine($line);
 464         runTestsOnPath($path, $file, $params);
 465     }
 466     close(LIBS2TEST);
 467
 468     print "\nComplete logging information will be found in dir: ".$g_sTempDir."dmake_out_$$/\n";
 469
 470     if ($nGlobalFailures > 0)
 471     {
 472         print "\nFailures over all occurred: $nGlobalFailures\n";
 473         print "\nPASSED FAILED.\n";
 474     }
 475     else
 476     {
 477         print "\nPASSED OK.\n";
 478     }
 479 }
 480
 481 # ------------------------------------------------------------------------------
 482
 483 # TODO:
 484 # -verbose
 485 # -fan   - \ | /
 486
 487 # END!
 488