#

# Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

# All rights reserved.

# This component and the accompanying materials are made available

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

# which accompanies this distribution, and is available

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

#

# Initial Contributors:

# Nokia Corporation - initial contribution.

#

# Contributors:

#

# Description: 

#

use strict;

##################################################################################

# These variables can be customised as required

# define some global variables - customise as required

my $REPORTDIR;

my $MAINLINEZIPDIR;

my $RELSUBSYSROOT;

my $TECHVIEWROOT;

# set variables which can be set from the environment. If no environment

# equivalent is found, it will set to the default

SetVariable(\$REPORTDIR, "REPORTDIR", "L:\\AutoSecTests");

SetVariable(\$MAINLINEZIPDIR, "MAINLINEZIPDIR", "\\\\builds01\\Master");

SetVariable(\$RELSUBSYSROOT, "RELSUBSYSROOT", "security");

# To include Techview in build set environment variable:

# TECHVIEWROOT=Techview

SetVariable(\$TECHVIEWROOT, "TECHVIEWROOT", "");

# host platforms define which platforms are to be built and tests to run. Target

# platforms are those where roms are build

my @HOSTPLATFORMS = ("wins", "winscw");

my @TARGETPLATFORMS = ("arm4", "thumb");

my @ROMPLATFORMS = ("lubbock", "assabet");

my @BUILDTYPES = ("udeb", "urel");

#

# END of customisable variables

####################################################################################

my $P4CLIENTNAME = ConfigureDefaultClient();

my $TESTCONFIGFILE;

my $SUBSYSTEMROOT;

# beech or cedar 

my $BUILDPLATFORM; 

# first get the date

my @DATEARRAY = split(/[ \/]/, `date /t`);

# command line arguments

my %ARGS = ();

# Parse command line parameters

ProcessCommandLine();

# now, DATEARRAY[0] will be day, 1 will be date of month, 2 will be month, 3 is year

my $RESULTDIR = "$REPORTDIR\\$DATEARRAY[3]$DATEARRAY[2]$DATEARRAY[1]";

# define the file where the config.txt file is post-processed

my $POSTPROCESSED = "$RESULTDIR\\postprocessed.txt";

# create a new directory for today

system("mkdir \"$RESULTDIR\"");

# create a logfile and error file

open  (LOGFILE, "> $RESULTDIR\\log.txt") || die "error opening for writing";

open  (ERRFILE, "> $RESULTDIR\\error.txt") || die "error opening for writing";

# Derive rootdrive from perforce client. Set up variables

# which required the root drive to be configured. Note that

# the test config file is only overwritten if not configured by

# the command line. By default it looks for config.txt in the current

# directory

my $ROOTDRIVE = "L:";

GetRootDrive();

if (!$TESTCONFIGFILE)

{

	use Cwd;

	my $dir = cwd();

	$TESTCONFIGFILE = "$dir\\config.txt";

}

if (!$SUBSYSTEMROOT)

{ 

	$SUBSYSTEMROOT = "$ROOTDRIVE\\$RELSUBSYSROOT";

}

if ($TECHVIEWROOT)

{

	$TECHVIEWROOT = "$ROOTDRIVE\\$TECHVIEWROOT";

}

# epoc root directory

my $EPOCROOT = "$ROOTDRIVE\\epoc32";

# add techview to build if requested

my @BUILDDIRS = "";

if ( $TECHVIEWROOT )

{

	@BUILDDIRS = ( $SUBSYSTEMROOT, "$TECHVIEWROOT\\toolkit\\startup\\group", "$TECHVIEWROOT\\apps\\appinstui\\group", "$TECHVIEWROOT\\apps\\secui\\group");

}

else

{

	@BUILDDIRS = ( $SUBSYSTEMROOT );

}

print "BUILDIRS = @BUILDDIRS\n";

# call main

main();

# main function 

sub main()

{

	print "REPORTDIR = $REPORTDIR\n";

	print "MAINLINEZIPDIR = $MAINLINEZIPDIR\n";

	print "SUBSYSTEMROOT = $SUBSYSTEMROOT\n";

	print "TESTCONFIGFILE = $TESTCONFIGFILE\n";

	print "TECHVIEWROOT = $TECHVIEWROOT\n";

	print "BUILDPLATFORM = $BUILDPLATFORM\n";

	# Figure out the second-latest release if none had been specified on the

	# command line - we do not want the latest in case it has not yet been released. 

	my $releasedir = "";

	my $platformsuffix = "";

	if ($BUILDPLATFORM)

	{

		$platformsuffix = "_$BUILDPLATFORM";

	}

	if (!$ARGS{"mainline"})

	{

		my $filelist = `dir $MAINLINEZIPDIR\\0????$platformsuffix /ad /b | sort /r`;

		my @filearray = split "\n", $filelist;

		$releasedir = $filearray[1];

	}

	else

	{

		$releasedir = "$ARGS{\"mainline\"}$platformsuffix";

	}

	# Display what's to be done

	ReportToFiles("------ Script run on $DATEARRAY[1]/$DATEARRAY[2]/$DATEARRAY[3] with the following options\n");

	ReportToFiles("------       Report directory: $REPORTDIR\n");

	ReportToFiles("------       Subsystem root: $SUBSYSTEMROOT\n");

	ReportToFiles("------       Test config file: $TESTCONFIGFILE\n");

	ReportToFiles("------       Built against MCL platform: $BUILDPLATFORM\n");

	if ($ARGS{s}) { ReportToFiles("------      Perforce synchronisation using client spec \"$P4CLIENTNAME\" on drive \"$ROOTDRIVE\"\n"); }

	if ($ARGS{u}) { ReportToFiles("------      Mainline unzip using build $releasedir\n"); }

	if ($ARGS{b}) { ReportToFiles("------      Build of production and test code\n"); }

	if ($ARGS{t}) { ReportToFiles("------      Running of test code on the host using $TESTCONFIGFILE\n"); }

	if ($ARGS{f}) { ReportToFiles("------      Build rom first\n"); }

	if ($ARGS{t}) { ReportToFiles("------      Running of test code on the host using $TESTCONFIGFILE\n"); }

	if ($ARGS{r}) 

	{ 

		ReportToFiles("------      Building of target roms: "); 

		map { ReportToFiles("$_ "); } @ROMPLATFORMS;

		ReportToFiles("\n");

	}

	ReportToFiles("------      Host builds used: ");

	map { ReportToFiles("$_ "); } @HOSTPLATFORMS;

	ReportToFiles("\n------      Target processor builds used: ");

	map { ReportToFiles("$_ "); } @TARGETPLATFORMS;

	ReportToFiles("\n------      Build types used: ");

	map { ReportToFiles("$_ "); } @BUILDTYPES;

	ReportToFiles("\n\n");

	# Do a perforce sync

	if ($ARGS{s})

	{

		DoPerforceSync();

	}

	# Now unzip the mainline

	if ($ARGS{u})

	{

		DoMainlineUnzip($releasedir);

	}

	# Build the post-processed config file if the test flag is on

	if ($ARGS{t})

	{

		ParseTestConfigFile();

	}

    # Build the tools

	if ($ARGS{o})

	{

		foreach my $bt (@BUILDTYPES)

		{

			DoBuildTools($bt);

		}

	}

	# Build rom first?

	if ( $ARGS{f} ) 

	{

		# Now build the target platforms - no testing required

		if ($ARGS{b})

		{

			foreach my $platform (@TARGETPLATFORMS)

			{

				foreach my $bt (@BUILDTYPES)

				{

					# Must build dummy midp2installerclient for cedar

					if ( $BUILDPLATFORM eq "cedar" )

					{

						my @tempbuilddirs = @BUILDDIRS;

						@BUILDDIRS = ("$SUBSYSTEMROOT\\appinst\\tsrc");

						print "Building dummy midp2installerclient....on $platform/$bt\n";

						DoBuild($platform, $bt);

						# now build the rest

						@BUILDDIRS = @tempbuilddirs;

					}

					DoBuild($platform, $bt);

				}

			}	

		}

		# Now build the roms if required

		if ($ARGS{r})

		{

			DoBuildRoms();

		}

	}

	# Build and test host platforms. They get built and then tested in order.

	# This is required as the EPOC C drive is shared between udeb and urel.

	# If the build/test is run together as a set, then the state of the C

	# drive will be restored

	foreach my $platform (@HOSTPLATFORMS)

	{

		foreach my $bt (@BUILDTYPES)

		{

			if ($ARGS{b})

			{

				DoBuild($platform, $bt);

			}

			if ($ARGS{t})

			{

				DoRunTests($platform, $bt);

			}

		}

	}

	# Now build the target platforms (unless this has been done in advance) - no testing required

	if ( !$ARGS{f} ) 

	{

		if ($ARGS{b})

		{

			foreach my $platform (@TARGETPLATFORMS)

			{

				foreach my $bt (@BUILDTYPES)

				{

					# Must build dummy midp2installerclient for cedar

					if ( $BUILDPLATFORM eq "cedar" )

					{

						my @tempbuilddirs = @BUILDDIRS;

						@BUILDDIRS = ("$SUBSYSTEMROOT\\appinst\\tsrc");

						print "Building dummy midp2installerclient....on $platform/$bt\n";

						DoBuild($platform, $bt);

						# now build the rest

						@BUILDDIRS = @tempbuilddirs;

					}

					DoBuild($platform, $bt);

				}

			}	

		}

		# Now build the roms if required

		if ($ARGS{r})

		{

			DoBuildRoms();

		}

	}

	my $timeoutput = `time /t`;

	ReportToFiles("\n------------------- Job finished at $timeoutput\n\n");

}

sub ConfigureDefaultClient

{

	# this subroutine figures out what default perforce client to use

	my $clientoutput = `p4 client -o`;

	if ($clientoutput =~ /\nClient:\s*([^\s]*)/ )

	{

		return $1;

	}

}

sub GetRootDrive

{

	# this subroutine derives the rootdrive from the perforce client

	my $clientoutput = `p4 client -o`;

	if ($clientoutput =~ /\nRoot:\s*(.):/ )

	{

		$ROOTDRIVE = "$1:"

	}

}

sub ProcessCommandLine

{

	use Getopt::Long;

	&GetOptions (\%ARGS, "a", "h", "s", "u", "b", "t", "r", "o", "f", "client=s", "configfile=s", "workdir=s", "mainline=s", "subsystemroot=s", "nohost", "notgt", "platform=s", @HOSTPLATFORMS, @TARGETPLATFORMS, @ROMPLATFORMS, @BUILDTYPES);

	# if the -a option is specified, this means that sync, unzip, build, run

	# tests, and rom options should be set

	if ($ARGS{a})

	{

		$ARGS{o} = $ARGS{s} = $ARGS{u} = $ARGS{b} = $ARGS{t} = $ARGS{r} = $ARGS{a};

	}

	# if the help option is specified, or none of the other arguments are specified,

	# or both beech and cedar requested, then display the help

	if ($ARGS{h} || (!$ARGS{s} && !$ARGS{u} && !$ARGS{b} && !$ARGS{t} && !$ARGS{r} && !$ARGS{o}))

	{

		print "Command line switches: \n";

		print "    -s        Do perforce synchronisation\n";

		print "    -u        Do unzipping from the mainline\n";

		print "    -b        Build the appropriate targets\n";

		print "    -t        Run the test suite\n";

		print "    -r        Build the roms\n";

        print "    -o        Build the tools\n";

		print "    -a        Do all of the above\n";

		print "    -f        Build rom First (before wins winscw)\n";

		print "    -h        Display this screen\n";

		print "\nOther options:\n";

		print "    --wins    Use the wins platform for building and running of host tests\n";

		print "    --winscw  Use the winscw platform for building and running of host tests\n";

		print "    --nohost  Do not use any host platform\n";

		print "    --arm4    Use the arm4 processor for rom building\n";

		print "    --thumb   Use the thumb processor for rom building\n";

		print "    --notgt   Do not use any target platform\n";

		print "    --assabet Build roms for assabet platform\n";

		print "    --lubbock Build roms for lubbock platform\n";

		print "    --udeb    Build udeb version only\n";

		print "    --urel    Build urel version only\n";

		print "\nParameters:\n";

		print "    --client=<client>   Specifies the perforce client to use (default: $P4CLIENTNAME)\n";

		print "    --workdir=<dir>     Specifies the working directory (default: $REPORTDIR)\n";

		print "    --subsystemroot=<dir> Specifies the root directory to build\n";

		print "    --configfile=<file> Specifies the test config file\n";

		print "    --mainline=<release number> Specifies the release number to use\n";

        print "    --platform=<platform name>  Specifies MCL platform. Default is beech. Set to none for pre MCL builds\n";

		print "\nExamples:\n";

		print "    perl -w RunTests.pl -b -t -r --wins --lubbock --thumb --platform=cedar --client=lon-julianl\n\n";

		print "    Uses drive m, client lon-julianl, build against cedar and builds and runs tests on the wins\n";

		print "    platform and builds roms for lubbock\n\n";

		print "    perl -w RunTests.pl -u -b --winscw --urel --notgt --mainline=01038\n\n";

		print "    Unzips mainline 01038_beech and builds only winscw/urel. Uses default client\n";

		print "    perl -w RunTests.pl -u -b --winscw --urel --notgt --platform=none --mainline=01038\n\n";

		print "    Unzips mainline 01038 and builds only winscw/urel. Uses default client\n";

		exit(0);

	}

	# Now parse the client, drive, and working directory parameters

	if ($ARGS{"client"})

	{

		$P4CLIENTNAME = $ARGS{"client"};

		$ENV{"P4CLIENT"} = $P4CLIENTNAME;

	}

	if ($ARGS{"configfile"})

	{

		$TESTCONFIGFILE = $ARGS{"configfile"};

	}

	if ($ARGS{"workdir"})

	{

		$REPORTDIR = $ARGS{"workdir"};

	}

	if ($ARGS{"subsystemroot"})

	{

		$SUBSYSTEMROOT = $ARGS{"subsystemroot"};

	}

	use Getopt::Long;

	# now parse the host options

	if ($ARGS{"nohost"})

	{

		@HOSTPLATFORMS = ();

	}

	else

	{

		ParseArguments(\@HOSTPLATFORMS);

	}

	# now parse the target platforms

	if ($ARGS{"notgt"})

	{

		@TARGETPLATFORMS = ();

	}

	else

	{

		ParseArguments(\@TARGETPLATFORMS);

	}

	# now parse the rom platforms and the build types

	ParseArguments(\@ROMPLATFORMS);

	ParseArguments(\@BUILDTYPES);

	if ($ARGS{"platform"})

	{

		$BUILDPLATFORM=$ARGS{"platform"};

		if ($BUILDPLATFORM eq "none")

		{

			# set compatibity for pre MCL builds

			$BUILDPLATFORM="";

		}

	}

	else

	{

		# default

		$BUILDPLATFORM="beech"; 

	}

}

sub ParseArguments

{

	# common parsing of arguments in an array - returns another array

	# which have the options specified.

	# If none specified, it returns ALL the options.

	#

	# eg. If -wins specified, and options = ("wins", "winscw"), then

	# return array is just ("wins"). If neither wins or winscw specified,

	# then returns both

	(my $options) = @_;

	my @retoptions = ();

	foreach my $opt (@$options)

	{

		if ($ARGS{$opt})

		{

			push(@retoptions, $opt);

		}

	}

	# change if we have at least one option specified

	if (scalar(@retoptions) > 0)

	{

		@$options = @retoptions;

	}

}

# subroutine to do a perforce sync 

sub DoPerforceSync

{

	print "Doing a Perforce synchronisation....\n";

	ExecAndOutputToLog("p4 sync -f $SUBSYSTEMROOT\\...");

    if ( $TECHVIEWROOT )

    {

        ExecAndOutputToLog("p4 sync -f $TECHVIEWROOT\\...");

    }

}

# subroutine to do the unzipping

sub DoMainlineUnzip

{

	my ($dir) = @_;

	print "Doing an unzip of mainline $MAINLINEZIPDIR\\$dir...\n";

	my @zipfiles = ("techview");

	# firstly, delete anything already there

	ExecAndOutputToLog("del \/F \/S \/Q $EPOCROOT");

	# unzip all the zipfiles

	map { ExecAndOutputToLog("t:\\tools\\unzip -o $MAINLINEZIPDIR\\$dir\\zips\\$_.zip -d $ROOTDRIVE\\"); } @zipfiles;

}

# subrountine to build or clean release or test build

# call RunAbld("<Directory>", "<Command>", "<Target>", "test" or "")

sub RunAbld

{

	my ($dir, $cmd, $target, $test, $bldtype) = @_;

	chdir ($dir);

	my $bldcommand = "abld $test $cmd -k $target $bldtype";

	my $bldoutput = ExecAndOutputToLog($bldcommand);	

	if ($cmd eq "build")

	{

		# match "error:" or "error(s)" or fatal error

		my @errout = grep(/(error(\(s\)|\:))|fatal error/i,  split("\n", $bldoutput));

		if (scalar(@errout) > 0)

		{

			print ERRFILE "-------- Errors found when running $bldcommand\n";

			map { print ERRFILE "$_\n"; } @errout;

			print ERRFILE "-------- End of errors for $bldcommand\n\n";

		}

	}

}

# builds the release and test code for a specified platform and mode

# eg WINS/UDEB

sub DoBuild

{

	my ($platform, $bt) = @_;

	RemoveWatchers($platform, $bt);

	foreach my $bd (@BUILDDIRS)

	{

		chdir ($bd);

		system("bldmake bldfiles");

		print "Building build targets.... $bd on $platform/$bt\n";

		ReportToFiles("\n------------------- Now building $bd on $platform/$bt\n\n");

		RunAbld($bd, "clean", $platform, "", $bt);

		RunAbld($bd, "clean", $platform, "test", $bt);

		RunAbld($bd, "build", $platform, "", $bt);

		RunAbld($bd, "build", $platform, "test", $bt);

	}

}

# builds the tools for deb or rel

sub DoBuildTools

{

	my ($bt) = @_;

    #adjust for unicode

    if ($bt eq "udeb")

    {

        $bt = "deb";

    }

    if ($bt eq "urel")

    {

        $bt = "rel";

    }

	foreach my $bd (@BUILDDIRS)

	{

		chdir ($bd);

		system("bldmake bldfiles");

		print "Building tools.... $bd on $bt\n";

		ReportToFiles("\n------------------- Now building $bd for tools on $bt\n\n");

		RunAbld($bd, "clean", "tools", "", $bt);

		RunAbld($bd, "build", "tools", "", $bt);

	}

}

# this subroutine executes the given command and outputs to the log file

sub ExecAndOutputToLog

{

	my ($cmd) = @_;

	my $timeoutput = `time /t`;

	my $cmdoutput = `$cmd 2>&1`;

	# capture output to log file

	print LOGFILE "-------- Output of $cmd run at $timeoutput";

	if ($cmdoutput) 

	{

		print LOGFILE "$cmdoutput\n";

	}

	else

	{

		print LOGFILE "(NO OUTPUT)\n";

	}

	if ($? != 0)

	{

		print ERRFILE "\n-------- Error code $? returned when executing:\n";

		print ERRFILE "-------- \"$cmd\".\n";

		if ($cmdoutput)

		{

			print ERRFILE "-------- Output:\n";

			print ERRFILE "$cmdoutput";

		}

	}

	return $cmdoutput;

}

# this subroutine executes all the tests as specified in the configuration file.

# It will run the tests for the specified platform/built type

#

# The configuration file has the following valid commands:

# 

# #include <filename> - includes another config file

# SYSTEMCMD <command and parameters> - executes a DOS command eg SYSTEMCMD copy a.txt b.txt

# DOTEST <testname> <scriptname> <logname> ... - executes a test

# COMP <filea> <fileb> - compares two files and logs result

#

# For SYSTEMCMD and COMP, the following variables get substituted

# - $C - the current EPOC C drive (eg o:\epoc32\wins\c)

# - $Z - the current EPOC Z drive (eg o:\epoc32\release\wins\udeb\z)

# - $RELEASE - the epoc release directory for this build (eg o:\epoc32\release\wins\udeb)

# - $EPOC - the epoc root (eg o:\epoc32)

# - $ROOT - the root drive (eg o:)

sub DoRunTests

{

	# platform and build type

	my ($p, $bt) = @_; 

	print "Running tests on platform $p/$bt\n";

	ReportToFiles("\n------------------- Now running tests on platform $p/$bt\n\n");

	# set the default directory to be the subsystem root

	chdir($SUBSYSTEMROOT);

	# Make the results directory

	my $testlogs = "$RESULTDIR\\testlogs";

	system("mkdir $testlogs");

	system("mkdir $testlogs\\$p");

	system("mkdir $testlogs\\$p\\$bt");

	# open the post processed file

	open (POSTFILE, "< $POSTPROCESSED") || die "error opening $POSTPROCESSED for reading";

	# open a separate report file for test results

	open (TESTREPFILE, "> $RESULTDIR\\testresults.$p.$bt.txt") || die "error opening for writing";

	my $timeoutput = `time /t`;

	print TESTREPFILE "-------- Test log file when running on platform $p/$bt at $timeoutput";

	my $cdrive = "$EPOCROOT\\$p\\c";

	while (<POSTFILE>)

	{

		my $line = $_;

		# check for a line with SYSTEMCMD <command>

		if ( $line =~ /^SYSTEMCMD[ ]+(.*)/ )

		{

			# Substitute $C for the cdrive, $Z for the zdrive, and $RELEASE

			# for the release path, etc

			my $cmd = $1;

			SubstitutePaths($p, $bt, \$cmd);

			print "  - executing system command: $cmd\n";

			ExecAndOutputToLog($cmd);

		}

		elsif ( $line =~ /^\s*$/ )

		{

			# if we have an empty line then do nothing

		}

		elsif ( $line =~ /^DOTEST\s+([^\s]+)[\s]+([^\s]+)[\s]+([^\s]+)/ )

		{

			# if this pattern matches DOTEST <cmd> <scriptfile> <logfile>,

			# then we execute this test - extra parameters can be supplied after the logfile

			print "  - running test: $1 $2 $3\n";

			ExecAndOutputToLog("$EPOCROOT\\release\\$p\\$bt\\$1 $2 $3 $'");

			# log files are assumed to be stored in \epoc32\wins\c

			my $outfile = "$cdrive\\$3";

			print TESTREPFILE "\n---- Result of test \"$1 $2 $3\"\n";

			if (-e $outfile)

			{

				# also, copy the log file into the results dir

				copy ($outfile, "$testlogs\\$p\\$bt\\$3");

				# check to see if there is a failure

				my $output = `type $outfile`;

				if ($output =~ /(\d+) tests failed out of (\d+)/)

				{

					print TESTREPFILE "     $1 tests failed out of $2\n";

					if ($1 ne "0") 

					{

						# if there is a fail, then print it in the test log

						print ERRFILE "-------- Logfile $outfile produced a failure result!\n";

						print ERRFILE "$output\n";

						print TESTREPFILE "     There was a test FAILURE\n";

					}

					else

					{

						print TESTREPFILE "     All tests SUCCEEDED\n";

					}

				}

				else

				{

					# if it doesn't conform to standard format, then need to notify

					print TESTREPFILE "     WARNING: non-standard log file format - check log\n";

				}

			}

			else

			{

				# if we get here, the output file didn't exist

				print ERRFILE "-------- Logfile $outfile does not exist - did $1 fail to build?\n";

				print TESTREPFILE "     ERROR! Log file $outfile does not exist\n";

			}

		}

		elsif ( $line =~ /^COMP\s+([^\s]+)[\s]+([^\s]+)/ )

		{

			# Parse our paths

			my $file1 = $1;

			my $file2 = $2;

			# substitute variables

			SubstitutePaths($p, $bt, \$file1);

			SubstitutePaths($p, $bt, \$file2);

			print "  - doing comparison on $file1 and $file2\n";

			print TESTREPFILE "\n---- Comparing $file1 and $file2\n";

			my $output = ExecAndOutputToLog("diff -q $file1 $file2");

			if ( $output =~ /differ/ )

			{

				print TESTREPFILE "     Comparison FAILED\n";

			}

			else

			{

				print TESTREPFILE "     Comparison SUCCESSFUL\n";

			}

		}

		else

		{

			ReportToFiles("**** Error test config line: $line");

		}

	}

	close (POSTFILE);

	close (TESTREPFILE);

}

# - $C - the current EPOC C drive (eg o:\epoc32\wins\c)

# - $Z - the current EPOC Z drive (eg o:\epoc32\release\wins\udeb\z)

# - $RELEASE - the epoc release directory for this build (eg o:\epoc32\release\wins\udeb)

# - $EPOC - the epoc root (eg o:\epoc32)

# - $ROOT - the root drive (eg o:)

# - $SUBSYSROOT - subsystem root e.g. security

sub SubstitutePaths

{

	my ($platform, $buildtype, $cmdref) = @_;

	my $cdrive = "$EPOCROOT\\$platform\\c";

	my $releasedir = "$EPOCROOT\\release\\$platform\\$buildtype";

	my $zdrive = "$releasedir\\z";

	${$cmdref} =~ s/\$C/$cdrive/g;

	${$cmdref} =~ s/\$Z/$zdrive/g;

	${$cmdref} =~ s/\$RELEASE/$releasedir/g;

	${$cmdref} =~ s/\$EPOC/$EPOCROOT/g;

	${$cmdref} =~ s/\$ROOT/$ROOTDRIVE/g;

	${$cmdref} =~ s/\$SUBSYSROOT/$RELSUBSYSROOT/g;

}

# This subroutine acts as a preprocessor for a config file. It

# expands the test config file and produced a file in POSTPROCESSED

sub ParseTestConfigFile

{

	use File::Copy;

	# Firstly, copy the configuration file into the postprocessed file

	copy($TESTCONFIGFILE, $POSTPROCESSED);

	# set up boolean to indicate if preprocessing of #include is done

	my $keepgoing = "1";

	while ($keepgoing)

	{

		# reset the keepgoing flag

		$keepgoing = "";

		# if we have to keep going, copy the postprocessed file into a temp

		my $tempfile = "$RESULTDIR\\temp.txt";

		move ($POSTPROCESSED, $tempfile);

		open  (TEMPFILE, "< $tempfile") || die "error opening $tempfile for reading";

		open  (POSTFILE, "> $POSTPROCESSED") || die "error opening $POSTPROCESSED for writing";

		# Now search the temp file for instances of #include

		while (<TEMPFILE>)

		{

			my $line = $_;

			# check for comments - use C++ style //

			if ( $line =~ /(.*)\/\/.*/ )

			{

				# set the keepgoing flag

				$keepgoing = "1";

				print POSTFILE "$1\n";

			}

			elsif ( $line =~ /\#include[ ]+\"([^\"]*)\"/ )

			{

				# set the keepgoing flag because a #include has been found

				$keepgoing = "1";

				# now write the entire contents of this file into the

				# the postprocessed file

				my $contents = `type $SUBSYSTEMROOT\\$1`;

				print POSTFILE "$contents\n";

			}

			elsif ( $line =~ /^\s*$/ )

			{

				# remove if we have only whitespaces

			}

			else 

			{

				print POSTFILE $line;

			}

		}

		close (TEMPFILE);

		close (POSTFILE);

		# delete the temp file

		unlink($tempfile);

	}

}

sub ReportToFiles

{

	# this function just prints a string to both the log file and the error file

	my ($str) = @_;

	print LOGFILE $str;

	print ERRFILE $str;

}

sub DoBuildRoms

{

	ReportToFiles("\n------------------- Now building roms\n\n");

	chdir ("$EPOCROOT\\rom");

	# create a new directory for the roms

	my $romdir = "$RESULTDIR\\roms";

	system("mkdir \"$romdir\"");

	# define the oby file to use

	my $oby_file = "techview.oby";

	# firstly, make sure the SecurityTests.iby file has been included from the techview.oby

	if (open(OBY, ">> include\\$oby_file"))

	{

		print OBY "\n#include <SecurityTests.iby>\n";

		close(OBY);

	}

	# Now go through the list of rom targets and build

	foreach my $rom (@ROMPLATFORMS)

	{

		ExecAndOutputToLog("tools\\buildrom -D__NOWATCHER__ -o$romdir\\$rom.img $rom $oby_file");

	}

}

sub SetVariable

{

	# Sets a variable from an environment variable or a default value if the

	# environment variable has not been set

	my ($variable, $env_name, $default) = @_;

	${$variable} = $ENV{$env_name};

	if (!${$variable})

	{

		${$variable} = $default;

	}

}

# remove the watchers (prevents connection intermittently to NTRas)

sub RemoveWatchers

{

	my ($platform, $bt) = @_;

	ReportToFiles("------------------- Removing watchers\n");

	if ( ($platform eq "wins") or ($platform eq "winscw") )

	{

		# emulator build, delete the dlls for beech and exes for cedar

		system("del $EPOCROOT\\release\\$platform\\$bt\\watcher.dll");

		system("del $EPOCROOT\\release\\$platform\\$bt\\z\\system\\libs\\watcher.dll");

		system("del $EPOCROOT\\release\\$platform\\$bt\\watcher.exe");

		system("del $EPOCROOT\\release\\$platform\\$bt\\z\\system\\libs\\watcher.exe");

	}

	else

	{

		# hardware. remove the watchers from startup script

		if ( $TECHVIEWROOT )

		{

			system("attrib -r $TECHVIEWROOT\\toolkit\\startup\\group\\start.rss");

			system("copy $SUBSYSTEMROOT\\testframework\\test\\autotesting\\startnowatchers.rss $TECHVIEWROOT\\toolkit\\startup\\group\\start.rss");

		}

	}

}