--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/installationservices/switestfw/test/autotesting/RunSecurityTests.pl Thu Dec 17 08:51:10 2009 +0200
@@ -0,0 +1,882 @@
+#
+# 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");
+ }
+ }
+}