1 #

     2 # Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

     3 # All rights reserved.

     4 # This component and the accompanying materials are made available

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

     6 # which accompanies this distribution, and is available

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

     8 #

     9 # Initial Contributors:

    10 # Nokia Corporation - initial contribution.

    11 #

    12 # Contributors:

    13 #

    14 # Description: 

    15 #

    16 

    17 #------------------------------------------------------------------------------------

    18 # Includes

    19 #------------------------------------------------------------------------------------

    20 use strict;

    21 use warnings;

    22 use Cwd; # for cwd

    23 use FindBin; # for FindBin:Bin

    24 use File::Path; # for mkpath

    25 use Date::Calc;

    26 use File::Copy;

    27 use lib "$FindBin::Bin/../lib";

    28 

    29 { # No globals.

    30     my $cgidir = GetCgiDir();

    31     

    32     if ( ! -e( $cgidir . "rerunsubs.pl" ) )

    33     {

    34         $cgidir = cwd;

    35         my $domain = "VideoApp_Domain";

    36         my $pos = index( $cgidir, $domain );

    37         if( $pos != -1 )

    38         {

    39             $cgidir = substr( $cgidir, 0, $pos + length( $domain ) ) . "\\videoplayer\\tsrc\\testing\\tools\\";

    40             

    41         }

    42     }

    43     require( $cgidir . "utils.pl" );

    44     require( $cgidir . "rerunsubs.pl" );

    45 }

    46 

    47 #------------------------------------------------------------------------------------

    48 # GLOBAL CODE

    49 #------------------------------------------------------------------------------------

    50 

    51 my $basePath = "testdrop"; # ATS XML

    52 my $dropFilePath = "ATS3Drop\\"; # All other files

    53 my $dropImagePath = "ATS3Drop\\images\\";

    54 my $dropBinaryPath = "ATS3Drop\\armv5_urel\\"; # Binaries

    55 

    56 my $currentPlanId = 0;

    57 my $currentSessionId = 0;

    58 my $currentSetId = 0;

    59 my $currentCaseId = 0;

    60 my $currentStepId = 0;

    61 

    62 # Attributes for files which are copied to device. Or SIS installations.

    63 my $ATSFILE_NAME = 0;

    64 my $ATSFILE_HARNESS = 1;

    65 my $ATSFILE_ENABLED = 2;

    66 my $ATSFILE_PASSRATE = 3;

    67 my $ATSFILE_SIGNIFICANT = 4;

    68 my $ATSFILE_TYPE = 5;

    69 my $ATSFILE_SRC = 6;

    70 my $ATSFILE_DST = 7;

    71 my $ATSFILE_COMMAND = 9;

    72 my $ATSFILE_DROPFULL_PATH = 10; # Contains the path in drop to the file

    73 my $ATSFILE_STEP_XML = 11; # XML defining the step

    74 my $ATSFILE_STEP_TIMEOUT = 12; # only for SIS file

    75 

    76 # These must be replaced when writing a step into XML file

    77 my $ATSXML_DROPPRIORITY = "ATSXML_DROPPRIORITY";

    78 my $ATSXML_TESTNAME = "ATSXML_TESTNAME";

    79 my $ATSXML_FLASH_IMAGE_NAME = "ATSXML_FLASH_IMAGE_NAME";

    80 my $ATSXML_TESTDEVICE = "ATSXML_TESTDEVICE";

    81 my $ATSXML_TESTPLAN_NAME = "ATSXML_TESTPLAN_NAME";

    82 my $ATSXML_TESTSESSION_NAME = "ATSXML_TESTSESSION_NAME";

    83 my $ATSXML_TESTSET_NAME = "ATSXML_TESTSET_NAME";

    84 my $ATSXML_STEP_NAME = "ATSXML_STEP_NAME";

    85 my $ATSXML_TESTCASE_NAME = "ATSXML_TESTCASE_NAME";

    86 my $ATSXML_STEP_HARNESS = "ATSXML_STEP_HARNESS";

    87 my $ATSXML_STEP_ENABLED = "ATSXML_STEP_ENABLED";

    88 my $ATSXML_STEP_PASSRATE = "ATSXML_STEP_PASSRATE";

    89 my $ATSXML_STEP_SIGNIFICANT = "ATSXML_STEP_SIGNIFICANT";

    90 my $ATSXML_STEP_COMMAND = "ATSXML_STEP_COMMAND";

    91 my $ATSXML_STEP_PARAM_TYPE = "ATSXML_STEP_PARAM_TYPE";

    92 my $ATSXML_STEP_PARAM_SRC = "ATSXML_STEP_PARAM_SRC";

    93 my $ATSXML_STEP_PARAM_DST = "ATSXML_STEP_PARAM_DST";

    94 my $ATSXML_STEP_RUNCASES_FILENAME = "ATSXML_STEP_RUNCASES_FILENAME";

    95 my $ATSXML_STEP_RUNCASES_TIMEOUT = "ATSXML_STEP_RUNCASES_TIMEOUT";

    96 #my $ATSXML_STEP_PARAM_COMPONENT_PATH = "ATSXML_STEP_PARAM_COMPONENT_PATH";

    97 my $ATSXML_STEP_RUNCASE_CASENAME = "ATSXML_STEP_RUNCASE_CASENAME";

    98 my $ATSXML_STEP_RUNCASE_FILENAME = "ATSXML_STEP_RUNCASE_FILENAME";

    99 my $ATSXML_EMAIL = "ATSXML_EMAIL";

   100 my $ATSXML_SIS_FILENAME = "ATSXML_SIS_FILENAME";

   101 my $ATSXML_STEP_TIMEOUT = "ATSXML_STEP_TIMEOUT";

   102 my $ATSXML_FETCH_PATH = "ATSXML_FETCH_PATH";

   103 my $ATSXML_CTC_PATH = "ATSXML_CTC_PATH";

   104 

   105 # These are initialized in the InitXml()

   106 my $ATSXML_HEADER_START;

   107 my $ATSXML_HEADER_END;

   108 my $ATSXML_FOOTER;

   109 my $ATSXML_PLANSTART;

   110 my $ATSXML_CREATEDIRS;

   111 my $ATSXML_FLASH;

   112 my $ATSXML_FORMAT_DRIVES;

   113 my $ATSXML_PLANEND;

   114 my $ATSXML_STEP;

   115 my $ATSXML_FETCH_STEPS;

   116 my $ATSXML_FETCH_STEP;

   117 my $ATSXML_CTCWRITE_STEP;

   118 my $ATSXML_STEP_DEFAULT;

   119 my $ATSXML_STEP_BINARY;

   120 my $ATSXML_STEP_RUNCASES;

   121 my $ATSXML_STEP_RUNCASES_WITH_BOOT;

   122 my $ATSXML_STEP_RUNCASES_INI;

   123 my $ATSXML_STEP_RUNCASES_INI_WITH_BOOT;

   124 my $ATSXML_STEP_RUNCASE;

   125 my $ATSXML_STEP_INSTALLSIS;

   126 my $ATSXML_POSTACTION;

   127 

   128 my $atsCfgFileName = "";

   129 my $atsUsername = "";

   130 my $atsPassword = "";

   131 

   132 my $paramStartDir = "..";

   133 my $paramVerbose = 1;

   134 my $paramDebug = 0;

   135 my $paramFindPkgFilePath = "";

   136 my $paramExecuteDrop = "";

   137 my $paramDontDeleteGeneratedFiles = 0;

   138 my $paramCTC = 0;

   139 my $paramNameFilter = "";

   140 my $paramSkipFlashCopy = 0;

   141 my $paramForcedBuild = "";

   142 my $paramRerunXml = 0;

   143 my $paramUseSecondaryIni = 0;

   144 my $paramCaseClass = "";

   145 

   146 my $globalAtsHost = "10.11.2.4";

   147 my $globalCtcExePath = "xxx";

   148 my @globalFlashFiles;

   149 my @globalSisFiles;

   150 my @globalPkgFiles;

   151 my $globalDeviceName = "";

   152 my $globalDeviceVersion = "";

   153 my $globalDeviceHWID = "";

   154 my $globalEmail = "";

   155 my $globalIgnoreSis = 0;

   156 my @globalFailedCfgs;

   157 

   158 # The code

   159 

   160 InitXml();

   161 

   162 ReadArgs();

   163 

   164 if($paramExecuteDrop ne "")

   165 {

   166     ExecuteDrop($paramExecuteDrop, 1);

   167 }

   168 else

   169 {

   170     if($atsCfgFileName eq "")

   171     {

   172         ShowHelp();

   173     }

   174 

   175 	ParseFile( $atsCfgFileName );

   176 }

   177 

   178 exit();

   179 

   180 

   181 #------------------------------------------------------------------------------------

   182 # ReadArgs

   183 #------------------------------------------------------------------------------------

   184 sub ReadArgs

   185     {

   186     ShowHelp() if(scalar(@ARGV) == 0);

   187 

   188     while(scalar(@ARGV) >= 1)

   189     {

   190         my $argument = shift(@ARGV);

   191         

   192         if($argument eq "-f")

   193         {

   194             $atsCfgFileName = shift(@ARGV)

   195         }

   196         elsif($argument eq "-u")

   197         {

   198             $atsUsername = shift(@ARGV)

   199         }

   200         elsif($argument eq "-p")

   201         {

   202             $atsPassword = shift(@ARGV)

   203         }

   204         elsif($argument eq "-h")

   205     	{

   206     		ShowHelp();

   207     	}

   208     	elsif($argument eq "-q")

   209     	{

   210     		$paramVerbose = 0;

   211     	}

   212     	elsif($argument eq "-d")

   213     	{

   214     		$paramVerbose = 1;

   215     		$paramDebug = 1;

   216     	}

   217     	elsif($argument eq -"filepath")

   218     	{

   219     	    $paramFindPkgFilePath = shift(@ARGV);

   220     	}

   221     	elsif($argument eq "-run")

   222     	{

   223     	    $paramExecuteDrop = shift(@ARGV);

   224     	    $paramVerbose = 1;

   225     	}

   226     	elsif($argument eq "-nodelete")

   227     	{

   228     	    $paramDontDeleteGeneratedFiles = 1;

   229     	}

   230     	elsif($argument eq "-ctcrom")

   231     	{

   232     	    $paramCTC = 1;

   233     	    $globalCtcExePath = "z:\\sys\\bin\\ctcman.exe";

   234     	}

   235     	elsif($argument eq "-ctcsis")

   236     	{

   237     	    $globalCtcExePath = "c:\\sys\\bin\\ctcman.exe";

   238     	    $paramCTC = 1;

   239     	}

   240     	elsif($argument eq "-dropname")

   241     	{

   242     	    $paramNameFilter = shift(@ARGV);

   243     	}

   244     	elsif($argument eq "-noflash")

   245     	{

   246     	    $paramSkipFlashCopy = 1;

   247     	}

   248     	elsif( $argument eq "-atshost" )

   249     	{

   250         	$globalAtsHost = shift(@ARGV);

   251         }

   252     	elsif( $argument eq "-forcebuild" )

   253     	{

   254         	$paramForcedBuild = shift(@ARGV);

   255         	if( !defined($paramForcedBuild) || ( $paramForcedBuild ne "udeb" && $paramForcedBuild ne "urel" ) )

   256         	{

   257         	    die("\n-forcebuild parameter must be 'udeb' or 'urel'");

   258         	}

   259         }

   260     	elsif( $argument eq "-rerun" )

   261     	{

   262         	$paramRerunXml = 1;

   263         	my $file = shift(@ARGV);

   264         	die("Could not read failed cases!") if ( Rerun_ReadFailedCases( $file, \@globalFailedCfgs ) );

   265             if( scalar( @globalFailedCfgs ) <= 0 )

   266             {

   267             	print("No fails to rerun!\n");

   268             	exit();

   269             }

   270         }

   271     	elsif( $argument eq "-allini" )

   272     	{

   273             $paramUseSecondaryIni = 1;

   274         }

   275         elsif( $argument eq "-caseclass" )

   276     	{

   277             $paramCaseClass = shift(@ARGV);

   278         }

   279     	else

   280     	{

   281     	    die("Unknown command line option: '$argument'.\n");

   282     	}

   283 

   284     }

   285     

   286     die("Parameter -f is required.\n") if( $atsCfgFileName eq "" );

   287 }

   288 

   289 #------------------------------------------------------------------------------------

   290 # ShowHelp

   291 #------------------------------------------------------------------------------------

   292 sub ShowHelp

   293 {

   294 print <<USAGE_EOF;

   295 genATSdrop.pl -f <drop or master cfg.txt> -u <ats username> -p <ats password>

   296 

   297 Params:

   298 -f <filename> Filename of ATS cfg file.

   299 -u <username> ATS username. not required.

   300 -p <password> ATS password. not required.

   301 -q            Quiet mode

   302 -d            Debug information

   303 -run xxx      Run xxx drop in the ATS farm. xxx can be a folder or a zip file (w/o .zip)

   304 -filepath xxx Where files from PKG are searched for, default is the path in PKG file.

   305 -h            help

   306 -nodelete     For default the script deletes generated files.

   307 -noflash      Skip copying flash files to drop.

   308 -ctcrom       CTC++ is installed in the ROM. Fetches the CTC result files from the device.

   309 -ctcsis       CTC++ is installed from SIS. Fetches the CTC result files from the device.

   310 -atshost      Address of ATS host to run the tests.

   311 -dropname xxx Runs only drops which match with xxx string.

   312 -forcebuild   udeb or urel -> forces to use the defined build for all executables read from PKGs

   313 -rerun xxx    Reads results from xml and writes only failed cases into ATS3 drop CFG files.

   314 -allini       Uses secondary testframework.ini file to run the cases, if it's found from init/all/ folder.

   315 

   316 Below is example for the ATS master cfg file. The commands override the 

   317 ATS drop cfg commands, except PKG command.

   318 

   319 [MASTERCFG]

   320 DEVICE Ivalo

   321 FLASH \\\\network\\flashimages\\core.fpsx

   322 FLASH \\\\network\\flashimages\\variant.fpsx

   323 FLASH \\\\network\\flashimages\\eraseuserdisk.fpsx

   324 SIS \\\\app\\sis\\app.sisx

   325 SIS \\\\app\\tsrc\\sistests.sisx

   326 IGNORESIS 

   327 PKG \\\\app\\tsrc\\data\\cenrepchanges.pkg

   328 EMAIL xxx

   329 ; Drop configs must be in tsrc folders and they must be defined after other commands.

   330 INC /ido/api/module1/tsrc/conf/ats_config.txt

   331 INC /ido/api2/module/tsrc/conf/ats_config.txt

   332 [EMDMASTERCFG]

   333 

   334 Available commands for the ATS drop cfg file. List order is also the recommended order in the cfg file.

   335 

   336  NAME XXX      Test drop name.

   337  PRIORITY xxx  Test drop execution priority, 0 is the highest

   338  DEVICE x1 x2 x3  x1 = Device name in the ATS system, x2 = device version (optional), x3 = device HWID (optional)

   339  FLASH         File to be flashed. Can be defined with path.

   340  PKG xxx       Text file listing the files which are copied into the device by ATS.

   341                Uses same format as Symbian PKG files.

   342  SIS x1        x1 = SIS/SISX file which needs to be installed.

   343  IGNORESIS     Master cfg only, ignores SIS commands afterwards.

   344  BOOT          Reboots the device. Testframework.ini must have cfg with cases Dummy1 and Dummy2.

   345  INI xxx       Command to execute ini file in ATS system.

   346  CFG xxx       Command to execute cfg in ATS system. Cfg files must be listed

   347                in the PKG files. No path support.

   348  CASELIST xxx  Command to execute invidual STIF cases from CFG files.

   349  FETCH xxx     Fetches file(s) from a directory. ( FETCH e:\\analyzetool\\* )

   350  EMAIL xxx     Email address(es) where ATS sends the report.

   351 

   352  USERNAME xxx  Username for ATS login

   353  PASSWORD xxx  Password for ATS login

   354 

   355 Example:

   356 

   357 [DROP]

   358 NAME STIF_TestDrop

   359 DEVICE Tube B1 1001

   360 FLASH \\\\network\\flashimages\\core.fpsx

   361 FLASH \\\\network\\flashimages\\variant.fpsx

   362 FLASH \\\\network\\flashimages\\eraseuserdisk.fpsx

   363 PKG \\\\app\\tsrc\\data\cenrepchanges.pkg

   364 SIS \\\\app\\sis\\app.sisx

   365 SIS \\\\app\\tsrc\\sis\\tests.sisx

   366 BOOT

   367 INI atsconfig\\drop1\\TestFramework.ini 1200

   368 EMAIL dude\@nokia.com

   369 [ENDDROP]

   370 

   371 USAGE_EOF

   372 

   373 	exit();

   374 }

   375 

   376 #------------------------------------------------------------------------------------

   377 # ParseFile

   378 # Parameters:

   379 #   $filename

   380 #------------------------------------------------------------------------------------

   381 sub ParseFile

   382 {

   383 	my($filename) = @_;

   384 	

   385 	# Read the file and check if it's drop conf or master conf file.

   386 	open(FILE_HANDLE, $filename) or die("ERROR! Could not open config file '" . $filename . "'\n");

   387 	my @lines = <FILE_HANDLE>;

   388 	close(FILE_HANDLE);

   389 

   390 	my $isDropFile = 0;

   391 	

   392 	foreach my $line (@lines)

   393 	{

   394 		if( $line =~ m/\[DROP\]/i || $line =~ m/\[ENDDROP\]/i )

   395 		{

   396 			$isDropFile++;

   397 		}

   398 	}

   399 	

   400 	if( $isDropFile >= 2 )

   401 	{

   402     	ParseAtsCfg( $filename );

   403     }

   404     else

   405     {

   406     	ParseMasterCfg( $filename );

   407     }

   408 }

   409 

   410 #------------------------------------------------------------------------------------

   411 # ParseMasterCfg

   412 # Parameters:

   413 #   $filename

   414 #------------------------------------------------------------------------------------

   415 sub ParseMasterCfg

   416 {

   417 	my($filename) = @_;

   418 		

   419 	my $index = 0;

   420 	

   421 	open(FILE_HANDLE, $filename) or die("ERROR! Could not open master config file '" . $filename . "'\n");

   422 	my @lines = <FILE_HANDLE>;

   423 	close(FILE_HANDLE);

   424 	

   425     while($index < scalar(@lines))

   426     {

   427         my $line = $lines[$index];

   428 

   429         my $cmd;

   430         my $params;

   431 		ReadCmdFromLine( \$line, \$cmd, \$params );

   432 

   433         #

   434         # CMD FLASH

   435         #

   436         if($cmd eq "FLASH")

   437         {

   438             push @globalFlashFiles, $params;

   439         }

   440 		

   441 		#

   442 		# CMD DEVICE

   443 		#

   444 		if( $cmd eq "DEVICE" )

   445 		{

   446 			my @paramArray = split( / /, $params );

   447 			$globalDeviceName = $paramArray[0] if( defined( $paramArray[0] ) );

   448 			$globalDeviceVersion = $paramArray[1] if( defined( $paramArray[1] ) );

   449 			$globalDeviceHWID = $paramArray[2] if( defined( $paramArray[2] ) );

   450 			print("Global device: $globalDeviceName\n");

   451 			print("Global device version: $globalDeviceVersion\n");

   452 			print("Global device HWID: $globalDeviceHWID\n");

   453 		}

   454 		

   455 		#

   456 		# CMD EMAIL

   457 		#

   458 		if( $cmd eq "EMAIL" )

   459 		{

   460 			$globalEmail = $params;

   461 		}

   462 

   463         #

   464         # CMD INC

   465         #

   466         if($cmd eq "INC")

   467         {

   468 			# Forward slashes to backward.

   469 			$params =~ s/\//\\/g;

   470 			

   471 			my $pos = index( $params, "tsrc" );

   472 			if( $pos != -1 )

   473 			{

   474 				print("\nReading config file $params\n");

   475 				my $path = substr( $params, 0, $pos+4 );

   476 				my $file = substr( $params, $pos+5 );

   477 				

   478 				$pos = index( $file, "conf" );

   479 				

   480 				die("INC file must be in conf directory! Incorrect params: $params") if( $pos == -1);

   481 

   482                 if( $pos != 0 )

   483                 {

   484                     $path .= "\\" . substr( $file, 0, $pos-1 );

   485                     $file = substr( $file, $pos );

   486                 }

   487 				

   488 				my $startDir = cwd;

   489 				

   490 				# Change where the master config file is.

   491 				if( rindex($filename, "\\") != -1 )

   492 				{

   493 					chdir( substr($filename, 0, rindex($filename, "\\") ) );

   494 				}

   495 				

   496 				# Go where the drop config file is.

   497 				chdir( $path );

   498 				

   499 				ParseAtsCfg( $file );

   500 				

   501 				chdir( $startDir );			

   502 			}

   503 			else

   504 			{

   505 				die("ERROR! The path $params is invalid, config must be under tsrc folder.\n");

   506 			}

   507 		}

   508 

   509         #

   510         # CMD SIS

   511         #

   512         if( $cmd eq "SIS" )

   513         {

   514             print("Master CFG has SIS: $params\n"); 

   515             push @globalSisFiles, $params;

   516         }

   517         

   518         #

   519         # CMD SIS

   520         #

   521         if( $cmd eq "IGNORESIS" )

   522         {

   523             print("Master CFG ignore sis command.\n"); 

   524             $globalIgnoreSis = 1;

   525         }

   526         

   527         #

   528         # CMD PKG

   529         #

   530         if( $cmd eq "PKG" )

   531         {

   532             print("Master CFG has PKG: $params\n"); 

   533             push @globalPkgFiles, $params;

   534         }				

   535 		

   536 		$index++;

   537 	}

   538 }	

   539 

   540 #------------------------------------------------------------------------------------

   541 # ParseAtsCfg

   542 # Parameters:

   543 #   $filename

   544 #------------------------------------------------------------------------------------

   545 sub ParseAtsCfg

   546 {

   547     my($filename) = @_;

   548     

   549 	open(FILE_HANDLE, $filename) or die("ERROR! Could not open drop config file '" . $filename . "'\n");

   550 	my @lines = <FILE_HANDLE>;

   551 	close(FILE_HANDLE);

   552 	

   553     my $index = 0;

   554 

   555     my $testname = "";

   556     my $testpriority = 0;

   557     my $deviceName = "";

   558     my $deviceVersion = "";

   559     my $deviceHWID = "";

   560     my $testClosed = 1; # is file handle closed?

   561     my $planStartWritten = 0;

   562     my $installationStepsWritten = 0;

   563     my $additionalFilesCopiedToDrop = 0; # have ini and flash files copied to drop already.

   564     my @atsFiles;

   565     my @flashFiles;

   566     my @sisFiles;

   567     my @pkgFiles;

   568     my @globalPkgFilesForConf;

   569     my $startOfDropIndex = 0;

   570     my $email = "";

   571 

   572     my $cmdDropStartRead = 0;

   573     my $cmdNameRead = 0;

   574     my $cmdDeviceRead = 0;

   575     my $cmdPkgRead = 0;

   576     my $cmdSisRead = 0;

   577     my $skipCurrentDrop = 0;

   578 

   579     my $bootDefined = 0;

   580     

   581     my @preRunCustomXmlData;

   582     my @postRunCustomXmlData;

   583     

   584     if( -e "custom\\prerun_custom.xml" )

   585     {

   586     	open( FILE_HANDLE, "custom\\prerun_custom.xml" ) or die("ERROR! Could not read conf/prerun_custom.xml.\n");

   587     	@preRunCustomXmlData = <FILE_HANDLE>;

   588     	close(FILE_HANDLE);

   589     }

   590     if( -e "custom\\postrun_custom.xml" )

   591     {

   592     	open( FILE_HANDLE, "custom\\postrun_custom.xml" ) or die("ERROR! Could not read conf/postrun_custom.xml.\n");

   593     	@postRunCustomXmlData = <FILE_HANDLE>;

   594     	close(FILE_HANDLE);

   595     }

   596 

   597     if( $paramCaseClass ne "" )

   598     {

   599         my $cgiDir = GetCgiDir();

   600         system("perl $cgiDir" . "genCfgs.pl -c $paramCaseClass");

   601 

   602         my @newCfgs;

   603         FindFiles(".\\conf_temp", "cfg", 1, \@newCfgs);

   604         if( scalar(@newCfgs) < 1 )

   605         {

   606             print("No class in cases. Aborting drop.\n");

   607             return;

   608         }

   609         

   610         push @globalPkgFilesForConf, "conf_temp\\cfgs.pkg";

   611     }

   612     

   613     while($index < scalar(@lines))

   614     {

   615         my $line = $lines[$index];

   616         

   617         my $cmd;

   618         my $params;		

   619 		ReadCmdFromLine( \$line, \$cmd, \$params );

   620 

   621         #

   622         # CMD DROP

   623         #

   624         if($cmd eq "[DROP]")

   625         {

   626             $startOfDropIndex = $index;

   627             # Reset variables for this drop

   628             $testpriority = 10;

   629             $testname = "";

   630             $deviceName = "";

   631             $deviceVersion = "";

   632             $deviceHWID = "";

   633             $planStartWritten = 0;

   634             $installationStepsWritten = 0;

   635             $additionalFilesCopiedToDrop = 0;

   636             undef( @atsFiles );

   637             undef( @flashFiles );

   638             undef( @sisFiles );

   639             undef( @pkgFiles );

   640             $email = "";

   641 

   642             $basePath = "";

   643 

   644             $currentPlanId = 0;

   645             $currentSessionId = 0;

   646             $currentSetId = 0;

   647             $currentCaseId = 0;

   648             $currentStepId = 0;

   649 

   650             $cmdDropStartRead = 1;

   651             $cmdNameRead = 0;

   652             $cmdDeviceRead = 0;

   653             $cmdPkgRead = 0;

   654             $cmdSisRead = 0;

   655         }

   656 

   657         #

   658         # CMD NAME

   659         #

   660         if($cmd eq "NAME" && !$skipCurrentDrop)

   661         {

   662             die ("Command [DROP] missing or NAME in wrong place. Line $index.") if(!$cmdDropStartRead);

   663             $testname = $params;

   664             

   665             $basePath = $params;

   666             $basePath =~ s/ /_/g;

   667             

   668             if( -e "$basePath.zip" ) 

   669             {

   670             	print("\ndel $basePath.zip\n");

   671             	system("del $basePath.zip");

   672             }

   673 

   674 			if( -e $basePath )

   675 			{

   676             	print("rmdir /s /q $basePath\n");

   677             	system("rmdir /s /q $basePath");

   678             }

   679 

   680             $skipCurrentDrop = 0;

   681             if( $paramNameFilter ne "" )

   682             {

   683                 if( !($testname =~ m/$paramNameFilter/i) )

   684                 {

   685                     $skipCurrentDrop = 1;

   686                     print("Skipping drop: $testname\n");

   687                 }

   688             }

   689 

   690             if( !$skipCurrentDrop )

   691             {

   692                 print("\nCreating testdrop: $testname\n");

   693 

   694                 # Create needed directories

   695                 mkdir($basePath);

   696                 mkdir($basePath . "\\" . $dropFilePath);

   697                 mkdir($basePath . "\\" . $dropImagePath);

   698                 mkdir($basePath . "\\" . $dropBinaryPath);

   699 

   700                 # Open XML file for writing

   701                 my $xmlfilename = "$basePath\\test.xml";

   702                 if(!open(FILE_HANDLE_XML, ">$xmlfilename") )

   703                 {

   704                     print("ERROR! Could not open file for writing '" . $xmlfilename . "'\n");

   705                     return 0;

   706                 }

   707                 $cmdNameRead = 1;

   708             }

   709             $testClosed = 0;

   710         }

   711 

   712         #

   713         # CMD PRIORITY

   714         #

   715         if($cmd eq "PRIORITY" && !$skipCurrentDrop)

   716         {

   717             die ("Command [DROP] missing or PRIORITY in wrong place. Line $index.") if(!$cmdDropStartRead);

   718             $testpriority = $params;

   719         }

   720 

   721         #

   722         # CMD DEVICE

   723         #

   724         if($cmd eq "DEVICE" && !$skipCurrentDrop)

   725         {

   726             die ("Command DEVICE in wrong place. Line $index.") if(!$cmdDropStartRead || $cmdPkgRead || $cmdSisRead );

   727             # Write XML header with test name and device

   728             die("Device must be set in the CFG!") if($params eq "");

   729             die("NAME must be set in the cfg!") if($testname eq "");

   730 

   731             my @paramArray = split( / /, $params );

   732             $deviceName = $paramArray[0] if( defined( $paramArray[0] ) );

   733             $deviceVersion = $paramArray[1] if( defined( $paramArray[1] ) );

   734             $deviceHWID = $paramArray[2] if( defined( $paramArray[2] ) );

   735             

   736             $deviceName = $globalDeviceName if( $globalDeviceName ne "" );

   737             $deviceVersion = $globalDeviceVersion if( $globalDeviceVersion ne "" );

   738             $deviceHWID = $globalDeviceHWID if( $globalDeviceHWID ne "" );

   739 

   740             my $data = $ATSXML_HEADER_START;

   741             $data =~ s/$ATSXML_TESTNAME/$testname/;

   742             $data =~ s/$ATSXML_TESTDEVICE/$deviceName/;

   743             $data =~ s/$ATSXML_DROPPRIORITY/$testpriority/;

   744 

   745             if( $deviceVersion ne "" )

   746             {

   747                 $data .= "            <property name=\"PROTO_VERSION\" value=\"$deviceVersion\" />\n";

   748             }

   749             if( $deviceHWID ne "" )

   750             {

   751                 $data .= "            <property name=\"HWID\" value=\"$deviceHWID\" />\n";

   752             }

   753 

   754             $data .= $ATSXML_HEADER_END;

   755 

   756             print FILE_HANDLE_XML ($data);

   757 

   758             if($paramVerbose)

   759             {

   760                 print("Device name: '$deviceName'\n");

   761                 print("Device version: '$deviceVersion'\n");

   762                 print("Device HWID: '$deviceHWID'\n");

   763             }

   764             $cmdDeviceRead = 1;

   765         }

   766 

   767         #

   768         # CMD FLASH

   769         #

   770         if($cmd eq "FLASH" && !$skipCurrentDrop)

   771         {

   772             die ("Command FLASH in wrong place. Line $index.") if(!$cmdDropStartRead || !$cmdNameRead || !$cmdDeviceRead || $cmdPkgRead || $cmdSisRead );

   773 

   774             push @flashFiles, $params;

   775         }

   776 

   777         #

   778         # Write the XML start before test run commands.

   779         #

   780         if( ( $cmd eq "INI" || $cmd eq "CFG" || $cmd eq "CASELIST" ) && !$skipCurrentDrop )

   781         {

   782             # Write plan start and flashing commands to XML.

   783             if($planStartWritten == 0)

   784             {

   785                 WriteXmlPlanStart(\*FILE_HANDLE_XML, $deviceName);

   786                 

   787                 my $refFlashFiles = \@flashFiles;

   788                 $refFlashFiles = \@globalFlashFiles if( scalar(@globalFlashFiles) > 0 );

   789 

   790                 foreach my $flashFile ( @$refFlashFiles )

   791               	{

   792 	            	my $file = GetPathFileName( $flashFile );

   793 	            	my $data = $ATSXML_FLASH;

   794 	            	$data =~ s/$ATSXML_FLASH_IMAGE_NAME/$file/;

   795 	            	print FILE_HANDLE_XML ($data);

   796 	            	print("Flash file: $file\n") if($paramVerbose);

   797                 }

   798 	          

   799                 # Steps to format drives.

   800                 #WriteXmlFormatDrives(\*FILE_HANDLE_XML);

   801                 

   802                 # Tsrc prerun custom steps.

   803                 if( scalar(@preRunCustomXmlData) > 0 ) 

   804                 {

   805                     print("Steps from prerun xml.\n");

   806                     print FILE_HANDLE_XML (@preRunCustomXmlData) 

   807                 }

   808                 

   809                 $planStartWritten = 1;

   810             }

   811 

   812             # Copy files to drop.

   813             if( $additionalFilesCopiedToDrop == 0 )

   814             {

   815                 # Copy flash files to drop.

   816                 my $refFlashFiles = \@flashFiles;

   817                 $refFlashFiles = \@globalFlashFiles if( scalar(@globalFlashFiles) > 0 );

   818             	CopyFlashFilesToDrop( $refFlashFiles, \@atsFiles );

   819             	

   820             	# Copy SIS files to drop and add to files to install.

   821             	my $refSisFiles = \@sisFiles;

   822             	$refSisFiles = \@globalSisFiles if( scalar( @globalSisFiles ) > 0 );

   823          	    foreach my $sisFile ( @$refSisFiles )

   824             	{

   825             	    CopySisFileToDrop( $sisFile, \@atsFiles );

   826             	}

   827 

   828                 my @allPkgFiles = ( @pkgFiles, @globalPkgFiles, @globalPkgFilesForConf );

   829 

   830             	foreach my $pkgFile ( @allPkgFiles )

   831             	{

   832             	    CopyPkgFilesToDrop( $pkgFile, \@atsFiles );

   833             	}

   834             	

   835             	# Copy testframework.ini of drop to drop. 

   836             	CopyTestframeworkIniOfDropToDrop( \@lines, $startOfDropIndex, \@atsFiles ) if( $paramCaseClass eq "" );

   837 

   838                 $additionalFilesCopiedToDrop = 1;

   839             }

   840 

   841             # XML file installation steps before these commands.

   842             if( $cmd eq "INI" || $cmd eq "CFG" || $cmd eq "CASELIST" )

   843             {

   844                 if($installationStepsWritten == 0)

   845                 {

   846                     print("File installation steps.\n") if($paramVerbose);

   847                     $installationStepsWritten = 1;

   848                     WriteXmlInstallationSteps(\@atsFiles, \*FILE_HANDLE_XML);

   849                 }

   850             }

   851         }

   852 

   853         #

   854         # CMD PKG

   855         #

   856         if( $cmd eq "PKG" && !$skipCurrentDrop )

   857         {

   858             die ("Command PKG in wrong place. Line $index.") if(!$cmdDropStartRead || !$cmdNameRead || !$cmdDeviceRead );

   859             push @pkgFiles, $params;

   860             $cmdPkgRead = 1;

   861         }

   862 

   863         #

   864         # CMD BOOT

   865         #

   866         if( $cmd eq "BOOT" )

   867         {

   868             $bootDefined = 1;

   869         }

   870 

   871         #

   872         # CMD INI & CFG

   873         #

   874         if( ($cmd eq "INI" || $cmd eq "CFG") && !$skipCurrentDrop)

   875         {

   876             die ("Command $cmd in wrong place. Line $index.") if(!$cmdDropStartRead || !$cmdNameRead || !$cmdDeviceRead );

   877             my $refData;

   878             if($cmd eq "CFG")

   879             {

   880                 if( !$bootDefined )

   881                 {

   882                     $refData = \$ATSXML_STEP_RUNCASES;

   883                 }

   884                 else

   885                 {

   886                     $refData = \$ATSXML_STEP_RUNCASES_WITH_BOOT;

   887                 }

   888 

   889             }

   890             else

   891             {

   892                 if( !$bootDefined )

   893                 {

   894                     $refData = \$ATSXML_STEP_RUNCASES_INI;

   895                 }

   896                 else

   897                 {

   898                     $refData = \$ATSXML_STEP_RUNCASES_INI_WITH_BOOT;

   899                 }

   900             }

   901 

   902             my $pos = index($params, " ");

   903             my $testfilename = substr($params, 0, $pos);

   904             my $timeout = substr($params, $pos);

   905 

   906             RemoveWhiteSpaces(\$testfilename);

   907             RemoveWhiteSpaces(\$timeout);

   908 

   909             $testfilename = GetPathFileName($testfilename);

   910 

   911             die("Commands INI and CFG must be have params file and timeout!") if($testfilename eq "" or $timeout eq "");

   912 

   913             WriteXmlRunStepsForFile($testfilename, $timeout, $refData, \*FILE_HANDLE_XML);

   914         }

   915 

   916         #

   917         # CMD SIS

   918         #

   919         if( $cmd eq "SIS" && !$skipCurrentDrop && !$globalIgnoreSis )

   920         {

   921             die ("Command $cmd in wrong place. Line $index.") if(!$cmdDropStartRead || !$cmdNameRead || !$cmdDeviceRead );

   922             push @sisFiles, $params;

   923             $cmdSisRead = 1;

   924         }

   925 

   926         #

   927         # CMD CASELIST

   928         #

   929         if($cmd eq "CASELIST" && !$skipCurrentDrop)

   930         {

   931             die ("Command CASELIST in wrong place. Line $index.") if(!$cmdDropStartRead || !$cmdNameRead || !$cmdDeviceRead );

   932             my @caseListLines;

   933             my $caseCount = 0;

   934 

   935         	if( !open(FILE_HANDLE_CASELIST, $params) )

   936         	{

   937         		die("ERROR! Could not open file '" . $params . "'\n");

   938         	}

   939         	@caseListLines = <FILE_HANDLE_CASELIST>;

   940         	close(FILE_HANDLE_CASELIST);

   941 

   942         	WriteXmlRunStepsForCases(\@caseListLines, \*FILE_HANDLE_XML);

   943         }

   944 

   945         #

   946         # CMD FETCH

   947         #

   948         if($cmd eq "FETCH" && !$skipCurrentDrop)

   949         {

   950             die ("Command FETCH in wrong place. Line $index.") if(!$cmdDropStartRead || !$cmdNameRead || !$cmdDeviceRead );

   951             WriteXmlFetchStep(\*FILE_HANDLE_XML, $params);

   952         }

   953 

   954         #

   955         # CMD EMAIL

   956         #

   957         if($cmd eq "EMAIL" && !$skipCurrentDrop)

   958         {

   959 			$email = $params;

   960 			$email = $globalEmail if( $globalEmail ne "" );

   961         }

   962 

   963  		#

   964         # CMD ENDDROP

   965         #

   966         if($cmd eq "[ENDDROP]" && !$skipCurrentDrop)

   967         {

   968             $skipCurrentDrop = 0;

   969             

   970             die ("[ENDDROP] in wrong place. Line $index.") if(!$cmdDropStartRead || !$cmdNameRead || !$cmdDeviceRead );

   971             

   972             # Tsrc prerun custom steps.

   973             if( scalar(@postRunCustomXmlData) > 0 ) 

   974             {

   975                 print("Steps from postrun xml.\n");

   976                 print FILE_HANDLE_XML (@postRunCustomXmlData) 

   977             }

   978             else

   979             {

   980                 WriteXmlFetchSteps(\*FILE_HANDLE_XML);

   981             }

   982 

   983             # End case, set, plan, session

   984             print FILE_HANDLE_XML ($ATSXML_PLANEND);

   985 

   986             ## Post action, fetches reports to network drive

   987             #print FILE_HANDLE_XML ($ATSXML_POSTACTION);

   988 

   989             WriteFileList(\@atsFiles, \*FILE_HANDLE_XML);

   990 

   991             # Write footer with email address

   992             my $data = $ATSXML_FOOTER;

   993             $data =~ s/$ATSXML_EMAIL/$email/;

   994             $data =~ s/$ATSXML_TESTNAME/$testname/;

   995             print FILE_HANDLE_XML ($data);

   996 

   997             if($testClosed == 0)

   998             {

   999                 $testClosed = 1;

  1000                 close(FILE_HANDLE_XML);

  1001             }

  1002         	

  1003         	if( $paramRerunXml )

  1004         	{

  1005             	my $failedCaseCount = 0;

  1006             	

  1007             	foreach my $pkgFile ( @pkgFiles )

  1008             	{

  1009             	    $failedCaseCount += GetFailedCasesCountForPkg( $pkgFile, \@globalFailedCfgs );

  1010             	}

  1011             	foreach my $pkgFile ( @globalPkgFiles )

  1012             	{

  1013             	    $failedCaseCount += GetFailedCasesCountForPkg( $pkgFile, \@globalFailedCfgs );

  1014             	}

  1015             	

  1016             	if( $failedCaseCount > 0 ) 

  1017             	{

  1018             	    ExecuteDrop($basePath, 0);

  1019             	}

  1020             	else

  1021             	{

  1022             	    print("No fails. Removing the drop.\n");

  1023                     if( -e "$basePath.zip" ) 

  1024                     {

  1025                     	print("\ndel $basePath.zip\n");

  1026                     	system("del $basePath.zip");

  1027                     }

  1028                 

  1029                 	if( -e $basePath )

  1030                 	{

  1031                     	print("rmdir /s /q $basePath\n");

  1032                     	system("rmdir /s /q $basePath");

  1033                     }

  1034             	}

  1035             }

  1036             else

  1037             {

  1038                 ExecuteDrop($basePath, 0);

  1039             }

  1040         }

  1041 

  1042         #

  1043         # CMD USERNAME

  1044         #

  1045         if($cmd eq "USERNAME" && !$skipCurrentDrop)

  1046         {

  1047             $atsUsername = $params if( $atsUsername ) eq "";

  1048         }

  1049 

  1050         #

  1051         # CMD PASSWORD

  1052         #

  1053         if($cmd eq "PASSWORD" && !$skipCurrentDrop)

  1054         {

  1055             $atsPassword = $params if( $atsPassword ) eq "";

  1056         }

  1057 

  1058         $index++;

  1059     }

  1060 

  1061     if($testClosed == 0)

  1062     {

  1063         close(FILE_HANDLE_XML);

  1064         $testClosed = 1;

  1065     }

  1066 

  1067     print("Done.\n");

  1068 }

  1069 

  1070 #------------------------------------------------------------------------------------

  1071 # ReadCmdFromLine

  1072 # Parameters:

  1073 #   $refLine, $refCmd, $refParams

  1074 # Return 

  1075 #  1 if it's a command, otherwise 0.

  1076 #------------------------------------------------------------------------------------

  1077 sub ReadCmdFromLine

  1078 {

  1079 	my ($refLine, $refCmd, $refParams) = @_;

  1080 	

  1081     RemoveWhiteSpaces($refLine);

  1082 

  1083 	$$refCmd = $$refLine;

  1084 	$$refParams = "";

  1085     

  1086     if(index($$refLine, ";") == 0 || index($$refLine, "#") == 0)

  1087     {

  1088 		return 0;

  1089     }

  1090 

  1091     my $pos = index($$refLine, " ");

  1092     if($pos != -1)

  1093     {

  1094         $$refCmd = substr($$refLine, 0, $pos);

  1095         $$refParams = substr($$refLine, $pos);

  1096     }

  1097     RemoveWhiteSpaces($refCmd);

  1098     RemoveWhiteSpaces($refParams);

  1099 

  1100     print("CMD: '$$refCmd', Params: '$$refParams'\n") if($paramDebug);

  1101     return 1;

  1102 }

  1103 

  1104 #------------------------------------------------------------------------------------

  1105 # CopySisFileToDrop

  1106 # Parameters:

  1107 #   $sisFile, $refAtsFiles

  1108 #------------------------------------------------------------------------------------

  1109 sub CopySisFileToDrop

  1110 {

  1111     my( $sisFile, $refAtsFiles ) = @_;

  1112     

  1113     # Copy file to drop.

  1114     my $pkgline = "\"$sisFile\" - \"c:\\testframework\\$sisFile\"";

  1115     print("SIS file to drop: $sisFile.\n") if($paramVerbose);

  1116     CopyFileToDrop($pkgline, $refAtsFiles, 1);

  1117     

  1118     $sisFile = GetPathFileName($sisFile);

  1119     

  1120     # Installation step.

  1121     my @atsFile;

  1122     $atsFile[$ATSFILE_SRC] = "c:\\testframework\\$sisFile";

  1123     $atsFile[$ATSFILE_STEP_XML] = $ATSXML_STEP_INSTALLSIS;

  1124     $atsFile[$ATSFILE_STEP_TIMEOUT] = 5000;    

  1125     push @$refAtsFiles, [ @atsFile ];

  1126 }

  1127 

  1128 #------------------------------------------------------------------------------------

  1129 # CopyTestframeworkIniOfDropToDrop

  1130 # Parameters:

  1131 #   $refAtsConfLines, $refAtsFiles

  1132 #------------------------------------------------------------------------------------

  1133 sub CopyTestframeworkIniOfDropToDrop

  1134 {

  1135     my( $refAtsConfLines, $startOfDropIndex, $refAtsFiles ) = @_;