Symaptic: os/mm/mmtestenv/mmtesttools/Scripts/RunTests.bat@260cb5ec6c19

     1 @rem

     2 @rem Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 @rem All rights reserved.

     4 @rem This component and the accompanying materials are made available

     5 @rem under the terms of "Eclipse Public License v1.0"

     6 @rem which accompanies this distribution, and is available

     7 @rem at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 @rem

     9 @rem Initial Contributors:

    10 @rem Nokia Corporation - initial contribution.

    11 @rem

    12 @rem Contributors:

    13 @rem

    14 @rem Description:

    15 @rem

    16 @rem = '--*-Perl-*--

    17 @echo off

    18 if "%OS%" == "Windows_NT" goto WinNT

    19 perl -x -S "%0" %1 %2 %3 %4 %5 %6 %7 %8 %9

    20 goto endofperl

    21 :WinNT

    22 perl -x -S "%0" %*

    23 if NOT "%COMSPEC%" == "%SystemRoot%\system32\cmd.exe" goto endofperl

    24 if %errorlevel% == 9009 echo You do not have Perl in your PATH.

    25 goto endofperl

    26 @rem ';

    27 #!perl

    28 #line 14

    29     eval 'exec perl.exe -S $0 ${1+"$@"}'

    30     if $running_under_some_shell;

    32 use strict; # important pragma

    33 use File::Copy;

    34 use File::Find;

    37 my @Month =("Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec");

    38 my ($sec,my $min,my $hour,my $mday,my $mon,my $year,my $wday,my $yday,my $isdst);

    41 my $BuildToUse="winscw";

    42 my $EpocCDrive = "$ENV{EPOCROOT}epoc32\\$BuildToUse\\c";

    43 my $ResultsDirectory = "$EpocCDrive\\Logs\\TestResults";

    44 my $TestFrameworkOpts="";

    45 my $TestFrameworkNoDelay="";

    46 my $Debug=0;

    47 my $Warning=0; #controls how pernickety the output is

    48 my $Cmd; #general variable to carry system commands

    49 my $CodeCover=0;

    50 my $ScriptToRun='[\S]+\.script';

    51 my $TimesToRun=1;

    54 if(@ARGV && (($ARGV[0] eq "-h") ||

    55      ($ARGV[0] eq "--h") ||

    56      ($ARGV[0] eq "-help") ||

    57      ($ARGV[0] eq "--help") ||

    58      ($ARGV[0] eq "help"))

    59 	 )

    60     {

    61     print "Runs all the Test Framework and Test Execute script files.\n";

    62     print "\nSyntax : runtests -b=sss -d -c -a -v=nnn -cc -rep=nnn -q\n";

    63 	print "-b   Compiler version to use [wins\|winscw) (default=$BuildToUse)\n";

    64     print "-d   Force to run testframework at debug mode \n";

    65     print "-c   Clean results directory ($ResultsDirectory)\n";

    66     print "-a   Full output in testframework console\n";

    67     print "-v   Provide verbose output 1=limited 2=maximum\n";

    68     print "-s   Define a script to be executed (ommitting causes all scripts to be run)\n";

    69     print "-cc  Only run release builds for Code Cover\n";

    70     print "-rep Repeat the test run a number of times\n";

    71     print "-q      Start testframework without the 20 second delay\n";

    73     exit 0;

    74     }

    78 use Getopt::Long;

    79 my %optctl = ();

    80 keys(%optctl)=10;

    81 unless (GetOptions (\%optctl, "b=s","d","c","v=i", "cc", "s=s","rep=i","a","q"))

    82   {exit 1;}

    86 if($optctl{"b"})

    87   {

    88   $BuildToUse=$optctl{"b"};

    89   if((lc($BuildToUse) ne "wins") && (lc($BuildToUse) ne "winscw"))

    90     {

    91 	print STDERR "only wins and winscw builds are supported\n";

    92 	exit 1;

    93 	}

    95    $EpocCDrive = "$ENV{EPOCROOT}epoc32\\$BuildToUse\\c";

    96    $ResultsDirectory = "$EpocCDrive\\Logs\\TestResults";

    97   }

    98 #repeat test run a number of times

    99 if($optctl{"rep"})

   100   {

   101   $TimesToRun = $optctl{"rep"};

   102   if(($TimesToRun < 1))

   103     {

   104     print STDERR "must specify a positive number of repeates\n";

   105     exit 1;

   106     }

   107   }

   110 #debug on

   111 if($optctl{"v"})

   112   {$Debug=$optctl{"v"};}

   114 if($Debug ==2)

   115   {

   116   print "Command line options:-\n";

   117   while ((my $key, my $val) = each %optctl)

   118     {print "$key  =>  $val\n";}

   119   }

   122 #Code Cover run

   123 if($optctl{"cc"})

   124   {$CodeCover=1;}

   127 if($Debug ==2)

   128   {

   129   print "Command line options:-\n";

   130   while ((my $key, my $val) = each %optctl)

   131     {print "$key  =>  $val\n";}

   132   }

   136 if($optctl{"c"})

   137   {

   138   print "Deleting Existing Results FIles\n";

   140   my @ExistingResultsFiles;

   141   my $ExistingResultsFile;

   142   find( sub { push @ExistingResultsFiles, $File::Find::name if /\.htm/ }, ($ResultsDirectory) );

   145   foreach $ExistingResultsFile (@ExistingResultsFiles)

   146     {

   147     $ExistingResultsFile =~ s/\//\\/g;

   148     $Cmd="del $ExistingResultsFile";

   149     if($Debug==2)

   150 	  {print "executing $Cmd\n";}

   151     system($Cmd);

   152 	}

   154   }

   156 if($optctl{"a"})

   157   {

   158   print "Full output in testframework console\n";

   159   $TestFrameworkOpts .= " -a";

   160   }

   162 if($optctl{"s"})

   163   {

   164   $ScriptToRun = $optctl{"s"};

   166   print "Looking for script file $ScriptToRun\n";

   167   }

   169 # Only add -q flag to textframework request

   170 if($optctl{"q"})

   171 	{

   172   	$TestFrameworkNoDelay .= " -q";

   173   	}

   175 my $UrelTestFramework = "$ENV{EPOCROOT}epoc32\\release\\$BuildToUse\\urel\\testframework.exe" . $TestFrameworkOpts . $TestFrameworkNoDelay;

   176 my $UdebTestFramework = "$ENV{EPOCROOT}epoc32\\release\\$BuildToUse\\udeb\\testframework.exe -t" . $TestFrameworkOpts . $TestFrameworkNoDelay;

   177 my $RecogUrelTestFramework = "$ENV{EPOCROOT}epoc32\\release\\$BuildToUse\\urel\\testframeworkrecognizer.exe" . $TestFrameworkOpts . $TestFrameworkNoDelay;

   178 my $RecogUdebTestFramework = "$ENV{EPOCROOT}epoc32\\release\\$BuildToUse\\udeb\\testframeworkrecognizer.exe" . $TestFrameworkOpts . $TestFrameworkNoDelay;

   179 my $NoneUrelTestFramework = "$ENV{EPOCROOT}epoc32\\release\\$BuildToUse\\urel\\testframeworkNone.exe" . $TestFrameworkOpts . $TestFrameworkNoDelay;

   180 my $NoneUdebTestFramework = "$ENV{EPOCROOT}epoc32\\release\\$BuildToUse\\udeb\\testframeworkNone.exe" . $TestFrameworkOpts . $TestFrameworkNoDelay;

   181 my $MMDDCapUrelTestFramework = "$ENV{EPOCROOT}epoc32\\release\\$BuildToUse\\urel\\testframeworkMMDDCap.exe" . $TestFrameworkOpts . $TestFrameworkNoDelay;

   182 my $UECapUrelTestFramework = "$ENV{EPOCROOT}epoc32\\release\\$BuildToUse\\urel\\testframeworkUECap.exe" . $TestFrameworkOpts . $TestFrameworkNoDelay;

   183 my $UrelEpocEmulator  = "$ENV{EPOCROOT}epoc32\\release\\$BuildToUse\\urel\\epoc.exe" . $TestFrameworkOpts;

   184 my $UdebEpocEmulator  = "$ENV{EPOCROOT}epoc32\\release\\$BuildToUse\\udeb\\epoc.exe" . $TestFrameworkOpts;

   185 my $eka2IdentifyFile  = "$ENV{EPOCROOT}epoc32\\release\\winscw\\udeb\\winsgui.dll"; # if file present, is EKA2 build

   186 my $UrelTestExecute = "$ENV{EPOCROOT}epoc32\\release\\$BuildToUse\\urel\\testexecute.exe" . $TestFrameworkOpts;

   187 my $UdebTestExecute = "$ENV{EPOCROOT}epoc32\\release\\$BuildToUse\\udeb\\testexecute.exe" . $TestFrameworkOpts;

   189 my $RecogniserCfgFile = "$EpocCDrive\\mm\\AutorunTests.cfg";

   190 my $copy_ini_secdisp = "perl secdisp_ini_append.pl append";

   191 my $delete_ini_secdisp = "perl secdisp_ini_append.pl restore";

   192 if($Debug>=1)

   193   {

   194   print "\nUsing $RecogniserCfgFile to configure the Epoc recogniser\n";

   195   }

   197 print "\nScanning $EpocCDrive for script files\n";

   198 my @ScriptFilesFound;

   199 my $ScriptFile;

   200 my $ScriptToRunTmp = $ScriptToRun;

   202 #Firstly, try to find an exact script name

   203 print "ScriptToRunTmp = $ScriptToRunTmp\n";

   205 if(!($ScriptToRun =~ /\.script/i))

   206   {$ScriptToRunTmp = $ScriptToRun .'\.script';}

   208 #find all the required script files

   209 find( sub { push @ScriptFilesFound, $File::Find::name if /^$ScriptToRunTmp$/i }, ($EpocCDrive) );

   211 #if no scripts were found, look for scripts that wildcard match

   212 if(@ScriptFilesFound < 1)

   213   {

   214   if(!($ScriptToRun =~ /\.script/i))

   215     {$ScriptToRunTmp = '[\S]*' . $ScriptToRun .'[\S]*\.script';}

   216   else

   217     {$ScriptToRunTmp = $ScriptToRun;}

   219   find( sub { push @ScriptFilesFound, $File::Find::name if /$ScriptToRunTmp/i }, ($EpocCDrive) );

   220   }

   222 if($Debug>=1)

   223   {

   224   my $len = @ScriptFilesFound;

   225   print "\nScanned $len script files in $EpocCDrive\n";

   226   foreach $ScriptFile (@ScriptFilesFound)

   227     {print "$ScriptFile\n";}

   228   }

   231 #look for any scripts that are called from other scripts; no need to call these directly

   232 my @IndirectScripts;

   233 my $IndirectScript;

   234 foreach $ScriptFile (@ScriptFilesFound)

   235   {

   236   unless (open(SCRIPTFILE,"$ScriptFile"))

   237     {

   238     print STDERR "Can't open $ScriptFile: $!\n";

   239     exit 1;

   240     }

   242   my $ScriptFileLine;

   243   my @ResultFileContents = <SCRIPTFILE>;

   245   foreach $ScriptFileLine (@ResultFileContents)

   246     {

   247     if($ScriptFileLine =~ /^RUN_SCRIPT[\s]+[\S]+[\s]*$/)

   248       {

   249 	  if($Debug==2)

   250         {print "File: $ScriptFile Line:  $ScriptFileLine\n";}

   252 	  $IndirectScript =  $ScriptFileLine;

   253 	  $_ = $IndirectScript;

   255 	  m/^RUN_SCRIPT[\s]+([\S]+)[\s]*$/;

   256       $IndirectScript=($1);

   258 	  if($Debug==2)

   259         {print "Secondary Script = $IndirectScript\n";}

   261 	  push @IndirectScripts, $IndirectScript;

   262 	  }

   263     }

   264   }

   267 #produce a list of the script files that need running

   268 my @ScriptsToRun;

   269 ScriptFile_LBL: foreach $ScriptFile (@ScriptFilesFound)

   270   {

   272   foreach $IndirectScript (@IndirectScripts)

   273     {

   274 	if($ScriptFile =~ /$IndirectScript/)

   275 	  {

   276 	  if($Debug==2)

   277         {print "Not running $ScriptFile directly\n";}

   278 	  next ScriptFile_LBL;}

   279 	}

   281   push @ScriptsToRun, $ScriptFile;

   282   }

   285 if($Debug>=1)

   286   {

   287   foreach $ScriptFile (@ScriptsToRun)

   288     {print "Running $ScriptFile\n";}

   289   }

   292 unless (open(TESTRUNLOG,">TestRunLog.txt"))

   293   {

   294   print STDERR "Can't open orphanedtests.txt: $!\n";

   295   exit 1;

   296   }

   298 unless (open(MASTERSCRIPT,">master.script"))

   299   {

   300   print STDERR "Can't open master.script: $!\n";

   301   exit 1;

   302   }

   303 unless (open(MASTERALLOCSCRIPT,">master_alloc.script"))

   304   {

   305   print STDERR "Can't open master_alloc.script: $!\n";

   306   exit 1;

   307   }

   309 #create a master script file, this could be usefull for running on hardware.

   310 foreach $ScriptFile (@ScriptsToRun)

   311   {

   312   $ScriptFile =~ s/\//\\/g;

   313   $ScriptFile =~ s/^[\s]*[a-z]://i;

   315   my $regex = quotemeta $EpocCDrive;

   316   $ScriptFile =~ s/$regex//gi;

   318   #alloc tests must be run under debug

   319   if($ScriptFile =~ /_alloc(_wm)?.script/i)

   320     {

   321     print MASTERALLOCSCRIPT "RUN_SCRIPT $ScriptFile\n";}

   322   else

   323     {print MASTERSCRIPT "RUN_SCRIPT $ScriptFile\n";}

   325   }

   326 close MASTERSCRIPT;

   327 close MASTERALLOCSCRIPT;

   330 #remove any alloc tests from list. Alloc tests must be run on debug builds, Code Cover tests

   331 #are only done against release builds.

   332 if($CodeCover==1)

   333   {

   334   my @ScriptsToRunTmp=();

   335   foreach $ScriptFile (@ScriptsToRun)

   336     {

   337     if(!($ScriptFile =~ /_alloc(_wm)?.script/i))

   338 	  {

   339       push @ScriptsToRunTmp, $ScriptFile;

   340 	  }

   341 	}

   342   @ScriptsToRun = @ScriptsToRunTmp;

   343   }

   346 my $TotalScriptFiles = @ScriptsToRun;

   347 if($TimesToRun > 1)

   348   {

   349   print "Running $TotalScriptFiles scripts  $TimesToRun times\n";

   350   }

   351 else

   352   {

   353   print "Running $TotalScriptFiles scripts\n";

   354   }

   357 my $RunCount=0;

   358 for ($RunCount = 0; $RunCount < $TimesToRun; $RunCount++)

   359   {

   360   my $ScriptsRun=0;

   361   #run each script

   362   foreach $ScriptFile (@ScriptsToRun)

   363     {

   364     $ScriptFile =~ s/\//\\/g;

   365     $ScriptFile =~ s/^[\s]*[a-z]://i;

   367     my $regex = quotemeta $EpocCDrive;

   368     $ScriptFile =~ s/$regex//gi;

   371     #alloc tests must be run under debug

   372     if($ScriptFile =~ /_recog_alloc.script/i)

   373 	    {

   374 	    $Cmd = "$RecogUdebTestFramework $ScriptFile";

   375         }

   376     elsif($ScriptFile =~ /_nocap_alloc.script/i)

   377        	{

   378       	$Cmd = "$NoneUdebTestFramework $ScriptFile";

   379        	}

   380     elsif(($ScriptFile =~ /_alloc.script/i) || ($ScriptFile =~ /_alloc_wm.script/i) || ($ScriptFile =~ /_debug.script/i) || ($optctl{"d"}) )

   381        	{

   382       	$Cmd = "$UdebTestFramework $ScriptFile";

   383        	}

   384     elsif($ScriptFile =~ /_recog.script/i)

   385        	{

   386       	$Cmd = "$RecogUrelTestFramework $ScriptFile";

   387        	}

   388     elsif($ScriptFile =~ /_nocap.script/i)

   389        	{

   390       	$Cmd = "$NoneUrelTestFramework $ScriptFile";

   391        	}

   392     elsif($ScriptFile =~ /_mmddcap.script/i)

   393        	{

   394       	$Cmd = "$MMDDCapUrelTestFramework $ScriptFile";

   395        	}

   396     elsif($ScriptFile =~ /_uecap.script/i)

   397        	{

   398       	$Cmd = "$UECapUrelTestFramework $ScriptFile";

   399        	}

   400     elsif($ScriptFile =~ /_secdisp.script/i)

   401       	{

   402      	#Take a backup of the existing ini files to .OLD and copy our ini files from the current dir to \epoc folders

   403 	    if(!(system($copy_ini_secdisp)==0))

   404       	    {

   405       	    print "Failure to execute - $Cmd: $!";

   406       	    print TESTRUNLOG "Failure to execute - $Cmd: $!\n";

   407       	    }

   408 	    $Cmd = "$UrelTestFramework $ScriptFile";

   409 	    }

   410     elsif($ScriptFile =~ /\\te_/i)

   411  	    {

   412  	    $Cmd = "$UdebTestExecute $ScriptFile";

   413  	    }

   414     elsif($ScriptFile =~ /_te.script/i)

   415  	    {

   416  	    $Cmd = "$UdebTestExecute $ScriptFile";

   417  	    }

   418     else

   419      	{

   420        	$Cmd = "$UrelTestFramework $ScriptFile";

   421        	}

   423     ($sec,my $min,my $hour,my $mday,my $mon,my $year,my $wday,my $yday,my $isdst) = localtime(time);

   424     print "Starting script at $hour:$min:$sec\n";

   425     print TESTRUNLOG "Starting script at $hour:$min:$sec\n";

   427     $ScriptsRun++;

   428     print "executing $Cmd ($ScriptsRun of $TotalScriptFiles)\n";

   430     print TESTRUNLOG "executing $Cmd\n";

   432     if(!(system($Cmd)==0))

   433       {

   434       print "Failure to execute - $Cmd: $!";

   435       print TESTRUNLOG "Failure to execute - $Cmd: $!\n";

   436       }

   437    if($ScriptFile =~ /_secdisp.script/i)

   438     {

   439     #Delete .ini files and rename  .OLD files to .ini files

   440     if(!(system($delete_ini_secdisp)==0))

   441          {

   442           print "Failure to execute - $Cmd: $!";

   443           print TESTRUNLOG "Failure to execute - $Cmd: $!\n";

   444           }

   445     }

   447     }#foreach $ScriptFile (@ScriptsToRun)

   449   if($TimesToRun > 1)

   450     {

   451     #now copy the results to a new numbered directory

   452     $Cmd = "xcopy /E /R /I /Y P:\\epoc32\\wins\\c\\Logs\\TestResults P:\\epoc32\\wins\\c\\Logs\\TestResults$RunCount";

   453     print "executing $Cmd";

   455     if(!(system($Cmd)==0))

   456       {

   457       print "Failure to execute - $Cmd: $!";

   458       print TESTRUNLOG "Failure to execute - $Cmd: $!\n";

   459       }

   460     }

   461   }

   465 $Cmd="del /F /Q $RecogniserCfgFile";

   466 if($Debug==2)

   467   {print "executing $Cmd\n";}

   468 system($Cmd);

   470 ($sec,my $min,my $hour,my $mday,my $mon,my $year,my $wday,my $yday,my $isdst) = localtime(time);

   471 print "Test run completed at $hour:$min:$sec\n";

   472 print TESTRUNLOG "Test run completed at $hour:$min:$sec\n";

   475 __END__

   477 :endofperl

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--