#

# 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";