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

# All rights reserved.

# This component and the accompanying materials are made available

# under the terms of "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;

use LWP::Simple;

use TestScriptResults;

use Getopt::Std;

use File::Find;

# Mistral tags the result files from test scripts in a particular format, depending on the test harness used to execute them. 

# We use these names to identify which files are results files.

my $KMistralCoreConfFileName = "-coreconf-";

my $KMistralTEFFileName = "-testexecute-";

my $KMistralTestFrameworkFileName = "-testframework"; # No trailing hyphen due to different security variants

#  It appears that Mistral uses a completely different file format for results from HW runs

my $KMistrealTEFFileNameHW = "testexecute";

my $KMistrealTFFileNameHW1 = "testframework";

my $KMistrealTFFileNameHW2 = "testframeworkmmddcap";

my $KMistrealTFFileNameHW3 = "testframeworkuecap";

my $KMistrealTFFileNameHW4 = "testframeworknone";

# Work in progress script outputs.

my $iKnownFails;

my $iUnknownFailsButKnownInRef;

my $iUnknownFailsButKnownInOtherCodelines;

my $iUnknownFails;

my $iMissingTests; 	

my $iVerbose;

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

##	Source test domain specific functionality

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

# Scans the test results summary page from the Mistral build and compiles a collection of the 

# URL paths for the log files.

# param1 - the URL to the Test Results HTML Summary page of the Mistral build

# returns - the array of logs' URLS

sub GetResultFilesFromMistral

	{

	my $aMistralTestResultsSummaryUrl = shift;

	my @fileNames;

	my $nextFileNamesIndex = 0;

	my $summaryContents = get "$aMistralTestResultsSummaryUrl"; # Returns undef if failure

	unless ($summaryContents)

		{

		print "\nERROR: Unable to retrieve source summary file from $aMistralTestResultsSummaryUrl\n";

		exit;

		}

	#Could add an optimisation to this to search for the <td class="error"> tag BUT doesn't take into account the crashed tests and would need to check here the pass/fail count

	#In addition this might lead to migration problems with Sirroco and certainly isn't appliable to developer's personal builds where we must scan each file

	#So it's simpler to do the brute force approach and keep all implementations alike, it doesn't take long anyway

	while ($summaryContents =~ s/href="(.*?($KMistralCoreConfFileName|$KMistralTEFFileName|$KMistralTestFrameworkFileName).*?\.html?)"//i)

		{

		$fileNames[$nextFileNamesIndex] = $1;

		$nextFileNamesIndex++;

		}

	# Scan this second so we don't accidentally cut off the filenames if they are matched against Winscw runs

	while ($summaryContents =~ s/href="(.*?($KMistrealTEFFileNameHW|$KMistrealTFFileNameHW1|$KMistrealTFFileNameHW2|$KMistrealTFFileNameHW3|$KMistrealTFFileNameHW4).*?\.html?)"//i)

		{

		$fileNames[$nextFileNamesIndex] = $1;

		$nextFileNamesIndex++;

		}

	unless ($fileNames[0])

		{

		print "\nERROR: No test result log files found, please ensure the -s parameter points to Mistral's TestResults.html summary page\n";	

		exit;

		}

	return @fileNames;

	}

# Parse the Mistral test results summary page and generate an array of TestScriptResults

# objects which contain all the required information such as script names, test counts

# and failures.

# param1 - the URL of the Test Results HTML Summary page for the Mistral build 

# returns - the array of parsed log data

sub PopulateResultsArrayFromMistral

	{

	my $aTestResultsSummaryPageUrl = shift;

	my @aResultsArray = ();

	my $nextFreeIndexInResultsArray = 0;

	my @fileNames = GetResultFilesFromMistral($aTestResultsSummaryPageUrl);

	foreach my $fileName (@fileNames)

		{

		my $testFileContents = get "$fileName";

		unless ($testFileContents)

			{

			print "\nERROR: Unable to open logfile $fileName\n";

			next;

			}

		my $scriptResults = TestScriptResults->TestScriptResults();

		$scriptResults->SetFilePath($fileName);		

		if (($fileName =~ m/.*?$KMistralTEFFileName(.*?)\.html?/i) || ($fileName =~ m/.*?$KMistrealTEFFileNameHW(.*?)\.html?/i))

			{

			$scriptResults->SetScriptName($1);

			if (!($testFileContents =~ m/TEST CASE SUMMARY:/i) && ($testFileContents =~ m/SUMMARY:/i))

				{

				# One of the old MM TEF tests which didn't use testcases

				$scriptResults->TEFNoTestcasesTest();

				$aResultsArray[$nextFreeIndexInResultsArray] = ScanTEFLogFileForFailures($scriptResults, \$testFileContents, 0);

				}

			else

				{

				$scriptResults->TEFTest();

				$aResultsArray[$nextFreeIndexInResultsArray] = ScanTEFLogFileForFailures($scriptResults, \$testFileContents, 1);

				}	

			}

		elsif ($fileName =~ m/.*?$KMistralCoreConfFileName(.*?)\.txt\.html?/i)

			{

			$scriptResults->SetScriptName($1);

			$scriptResults->CoreConfTest();

			$aResultsArray[$nextFreeIndexInResultsArray] = ScanCoreConfLogFileForFailures($scriptResults, \$testFileContents);

			}

		elsif (($fileName =~ m/.*?$KMistralTestFrameworkFileName[^\-]*?\-(.*?)\.html?/i) || ($fileName =~ m/.*?$KMistrealTFFileNameHW2(.*?)\.html?/i) || ($fileName =~ m/.*?$KMistrealTFFileNameHW3(.*?)\.html?/i) || ($fileName =~ m/.*?$KMistrealTFFileNameHW4(.*?)\.html?/i) || ($fileName =~ m/.*?$KMistrealTFFileNameHW1(.*?)\.html?/i))

			{

			$scriptResults->SetScriptName($1);

			$scriptResults->TestFrameworkTest();

			$aResultsArray[$nextFreeIndexInResultsArray] = ScanTestFrameworkLogFileForFailures($scriptResults, \$testFileContents);

			}

		else

			{

			print "\nWARNING: Results file has unrecognised format - $fileName.\n";			

			}

		$nextFreeIndexInResultsArray++;	

		}

	return \@aResultsArray;

	}

# Walk the file path provided by the developer for his local machine, parse test logs

#  and generate an array of TestScriptResults objects which contain all the required 

# information such as script names, test counts and failures.

# param1 - the pathname of a folder containing the test results

# returns - the array of parsed log data

sub PopulateResultsArrayFromLocalMachine

	{

	my $aTestResultsPath = shift;

	my @aResultsArray = ();

	my $nextFreeIndexInResultsArray = 0;

	my @directories = ("$aTestResultsPath");

	my @fileNames;

	find( sub { push @fileNames, $File::Find::name if /\.html?$/ }, @directories );

	foreach my $fileName (@fileNames)

		{

		my $testFileContents = do { local $/; open(I,"$fileName"); <I> };

		my $scriptResults = TestScriptResults->TestScriptResults();

		$scriptResults->SetFilePath($fileName);

		$fileName =~ m/([^\\\/\.]*)\.[^\\\/]*\Z/;

		$scriptResults->SetScriptName($1);

		if ($testFileContents =~ m/Core Loader Conformance Suite/)

			{

			$scriptResults->CoreConfTest();

			$aResultsArray[$nextFreeIndexInResultsArray] = ScanCoreConfLogFileForFailures($scriptResults, \$testFileContents);

			}

		elsif ($testFileContents =~ m/TestFrameworkMain.cpp/)

			{

			$scriptResults->TestFrameworkTest();

			$aResultsArray[$nextFreeIndexInResultsArray] = ScanTestFrameworkLogFileForFailures($scriptResults, \$testFileContents);

			}

		elsif ($testFileContents =~ m/TEF Version/)

			{

			if ($testFileContents =~ m/TEST CASE SUMMARY:/i)

				{

				$scriptResults->TEFTest();

				$aResultsArray[$nextFreeIndexInResultsArray] = ScanTEFLogFileForFailures($scriptResults, \$testFileContents, 1);

				}

			else

				{

				# One of the old MM TEF tests which didn't use testcases

				$scriptResults->TEFNoTestcasesTest();

				$aResultsArray[$nextFreeIndexInResultsArray] = ScanTEFLogFileForFailures($scriptResults, \$testFileContents, 0);

				}			

			}

		else

			{

			print "\nWARNING: Results file has unrecognised format - $fileName.\n";	

			}

		$nextFreeIndexInResultsArray++;	

		}

	return \@aResultsArray;

	}

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

##	Test harness specific functionality

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

# Parses a TF log file for failures, inconclusives and crashes

# param1 - the TestScriptResults object to populate

# param2 - reference to the contents of the log file

# returns - the TestScriptResults object containing the parsed data

sub ScanTestFrameworkLogFileForFailures

	{

	my ($aScriptResults, $aLogFileContents) = @_;

	my $testFileContents = $$aLogFileContents;

	my $numberOfTests = 0;

	# Search for test case results, which take the following form:

	#04/09/2002 15:51:39:772    V   Log.cpp 736 Test Result for TSI_ICL_BTRANS_01:MM_ICL_BTRANS_I_0202_CP is PASS

	while ($testFileContents =~ s/Test[\s]+Result[\s]+for[\s]+[\S]+:([\_|\-|\S]+)[\s]+is[\s]+([\_|\-|\S]+)[\s]*\<\/font\>//)

		{

		my $testId  = $1;

	    my $result = $2;

	    $numberOfTests++;

		if ($result =~ /PASS/)

			{

			# Do nothing

			}

		elsif ($result =~ /INCONCLUSIVE/)

			{

			$aScriptResults->AddInconclusiveResult($testId);

			}

		else

			{

			# Treat all other results as failure

			$aScriptResults->AddFailureResult($testId);

			}

		}

	$aScriptResults->SetTotalTestCount($numberOfTests);

	unless ($testFileContents =~ m/Test Results Summary/)

		{

		# Test file summary not in the log file - the test has crashed

		$aScriptResults->TestCrashed();

		}

	return $aScriptResults;

	}

# Parses a TEF log file for failures, inconclusives and crashes

# param1 - the TestScriptResults object to populate

# param2 - reference to the contents of the log file

# param3 - boolean whether the test is using testcases (older MM tests didn't, in which case we use the test steps)

# returns - the TestScriptResults object containing the parsed data

sub ScanTEFLogFileForFailures

	{

	my ($aScriptResults, $aLogFileContents, $aTestcasesInUse) = @_;

	my $testFileContents = $$aLogFileContents;

	my $numberOfTests = 0;

	# Search for test case results, which take the following form:

	# 02:56:42:145 c:\mm\tsu_3gp_compose_api_te.script Line = 58 Command = END_TESTCASE MM-3GP-COMP-U-0003-CP ***TestCaseResult = PASS 

	# Or if testcases not in use in this script file test step results, which take the following form:

	# 14:20:51:459 c:\mm\tsu_mmf_aclnt_securedrmtestdata.script Line = 36 Command = RUN_TEST_STEP 1000 RTAUtils ImportDrmArchive c:\mm\tsu_mmf_aclnt_securedrmtestdata.ini ImportSmallWavDrmArchiveAudio ***Result = UNEXECUTED 

	while (($testFileContents =~ s/Command[\s]+=[\s]+END\_TESTCASE[\s]+([\_|\-|\S]+)[\s]+\*\*\*TestCaseResult[\s]+=[\s]+([\_|\-|\S]+)[\s]*\<\/font\>//)

			|| (!$aTestcasesInUse && ($testFileContents =~ s/Command[\s]+=[\s]+RUN\_TEST\_STEP[\s]+\d*[\s]+.*?[\s]+([\_|\-|\S]+)[\s]+.*?\*\*\*Result[\s]+=[\s]+([\_|\-|\S]+)[\s]*\<\/font\>//)))

		{

		my $testId  = $1;

	    my $result = $2;

	    $numberOfTests++;

		if ($result =~ /PASS/)

			{

			# Do nothing

			}

		elsif ($result =~ /INCONCLUSIVE/)

			{

			$aScriptResults->AddInconclusiveResult($testId);

			}

		else

			{

			# Treat all other results as failure

			$aScriptResults->AddFailureResult($testId);

			}

		}

	$aScriptResults->SetTotalTestCount($numberOfTests);

	# Testcase scripts use TEST CASE SUMMARY, non-testcase scripts just use SUMMARY

	unless ($testFileContents =~ m/SUMMARY:/)

		{

		# Test file summary not in the log file - the test has crashed

		$aScriptResults->TestCrashed();

		}

	return $aScriptResults;	

	}

# Parses a CoreConf log file for failures, inconclusives and crashes

# param1 - the TestScriptResults object to populate

# param2 - reference to the contents of the log file

# returns - the TestScriptResults object containing the parsed data	

sub ScanCoreConfLogFileForFailures

	{

	my ($aScriptResults, $aLogFileContents) = @_;

	my $testFileContents = $$aLogFileContents;

	if ($testFileContents =~ s/\*\*\*\s*?Summary of tests executed(.*\n)*//)

		{

		my $numberOfTests = 0;

		# Parse the summary listings

		while($testFileContents =~ s/\*\*\*\s*?Passed tests:((.*\n)*?)\*\*\*\s*?Failed tests:.*\n((\*\*\*.*\n)*)//)

			{

			my $passingTests = $1;

			my $failingTests = $3;

			# Passing tests

			while ($passingTests =~ s/\*\*\*[\s]*?\S+[\s]*\n//)

				{

				$numberOfTests++;

				}

			# Failing tests

			while ($failingTests =~ s/\*\*\*[\s]*?(\S+)[\s]*\n//)

				{

				$aScriptResults->AddFailureResult($1);

				$numberOfTests++;

				}			

			}

		$aScriptResults->SetTotalTestCount($numberOfTests);		

		}

	else

		{

		# Test file summary not in the log file - the test has crashed

		$aScriptResults->TestCrashed();		

		}

	return $aScriptResults;		

	}

# Gets the test case count from a Test Execute Framework log file

# param1 - a reference to the contents of the TEF log file

#returns - The number of test cases in the script or -1 if the summary could not be found

sub GetTEFTestCount

	{

	my $aReferenceLogContents = shift;

	my $refContents = $$aReferenceLogContents;

	if ($refContents =~ m/TEST CASE SUMMARY:(.*\n)*?.*?PASS =\s*(\d*)(.*\n)*?.*?FAIL =\s*(\d*)(.*\n)*?.*?INCONCLUSIVE =\s*(\d*)/)

		{

		my $result = $2 + $4 + $6;

		return $result;

		}

	if ($refContents =~ m/SUMMARY:(.*\n)*?.*?PASS =\s*(\d*)(.*\n)*?.*?FAIL =\s*(\d*)(.*\n)*?.*?ABORT =\s*(\d*)(.*\n)*?.*?PANIC =\s*(\d*)(.*\n)*?.*?INCONCLUSIVE =\s*(\d*)(.*\n)*?.*?UNKNOWN =\s*(\d*)(.*\n)*?.*?UNEXECUTED =\s*(\d*)/)	

		{

		# One of the MM tests that doesn't use testcases

		my $result = $2 + $4 + $6 + $8 + $10 + $12 + $14;

		return $result;

		}									

	# Summary not found, we crashed

	return -1;

	}

# Gets the test count from a Test Framework log file

# param1 - a reference to the contents of the Test Framework log file

#returns - The number of test cases in the script or -1 if the summary could not be found	

sub GetTestFrameworkTestCount

	{

	my $aReferenceLogContents = shift;

	my $refContents = $$aReferenceLogContents;

	unless ($refContents =~ m/Test Results Summary(.*\n)*?.*?Total\s*:(\d*)\s*\n/)

		{

		# Summary not found, we crashed

		return -1;

		}

	return $2;

	}

# Gets the test count from an OpenMAX IL Core Conformance log file

# param1 - a reference to the contents of the Core Conformance log file

#returns - The number of test cases in the script or -1 if the summary could not be found	

sub GetCoreConfTestCount

	{

	my $aReferenceLogContents = shift;

	my $refContents = $$aReferenceLogContents;

	unless ($refContents =~ m/\*\*\*\s*Summary of tests executed(.*\n)*?\*\*\*\s*Total :\s*(\d*)\s*\n/)

		{

		# Summary not found, we crashed

		return -1;

		}

	return $2;

	}

# Scans a TEF log looking for the test specified and checks if it returned inconclusive

# param1 - the test name

# param2 - reference to the contents of the log file, the test case result is removed from the argument if passed by ref

# param3 - whether the TEF script uses testcases

# returns - 1 if it returned inconclusive, 0 otherwise	

sub MatchingTEFInconclusiveResult	

	{

	my $aInconclusive = shift;

	my $aReferenceLogContents = shift;

	my $aTestcasesInUse = shift;

	my $refContents = $$aReferenceLogContents;

	if ($aTestcasesInUse)

		{

		if ($refContents =~ s/Command[\s]+=[\s]+END\_TESTCASE[\s]+$aInconclusive[\s]+\*\*\*TestCaseResult[\s]+=[\s]+([\_|\-|\S]+)[\s]*\<\/font\>//)

			{

			if ($1 eq "INCONCLUSIVE")

				{

				return 1;

				}

			}

		}

	else

		{

		if ($refContents =~ s/Command[\s]+=[\s]+RUN\_TEST\_STEP[\s]+\d*[\s]+.*?[\s]+$aInconclusive[\s]+.*?\*\*\*Result[\s]+=[\s]+([\_|\-|\S]+)[\s]*\<\/font\>//)

			{

			if ($1 eq "INCONCLUSIVE")

				{

				return 1;

				}

			}

		}

	return 0;

	}

# Scans a TestFramework log looking for the test specified and checks if it returned inconclusive

# param1 - the test name

# param2 - reference to the contents of the log file, the test case result is removed from the argument if passed by ref

# returns - 1 if it returned inconclusive, 0 otherwise		

sub MatchingTFInconclusiveResult 

	{

	my $aInconclusive = shift;

	my $aReferenceLogContents = shift;

	my $refContents = $$aReferenceLogContents;

	if ($refContents =~ s/Test[\s]+Result[\s]+for[\s]+[\S]+:$aInconclusive[\s]+is[\s]+([\_|\-|\S]+)[\s]*\<\/font\>//)

		{

		if ($1 eq "INCONCLUSIVE")

			{

			return 1;

			}

		}

	return 0;

	}

# Scans a TEF log looking for the test specified and checks if it returned an error

# param1 - the test name

# param2 - reference to the contents of the log file, the test case result is removed from the argument if passed by ref

# param3 - whether the TEF script uses testcases

# returns - 1 if it returned an error, 0 otherwise		

sub MatchingTEFErrorResult 

	{

	my $aFail = shift;

	my $aReferenceLogContents = shift;

	my $aTestcasesInUse = shift;

	my $refContents = $$aReferenceLogContents;

	if ($aTestcasesInUse)

		{

		if (not $refContents =~ s/Command[\s]+=[\s]+END\_TESTCASE[\s]+$aFail[\s]+\*\*\*TestCaseResult[\s]+=[\s]+([\_|\-|\S]+)[\s]*\<\/font\>//)

			{

			return 0;

			}

		if (($1 eq "PASS") || ($1 eq "INCONCLUSIVE"))

			{

			return 0;

			}

		}

	else

		{

		if (not $refContents =~ s/Command[\s]+=[\s]+RUN\_TEST\_STEP[\s]+\d*[\s]+.*?[\s]+$aFail[\s]+.*?\*\*\*Result[\s]+=[\s]+([\_|\-|\S]+)[\s]*\<\/font\>//)

			{

			return 0;

			}

		if (($1 eq "PASS") || ($1 eq "INCONCLUSIVE"))

			{

			return 0;

			}

		}

	return 1;

	}	

# Scans a TestFramework log looking for the test specified and checks if it returned an error

# param1 - the test name

# param2 - reference to the contents of the log file, the test case result is removed from the argument if passed by ref

# returns - 1 if it returned an error, 0 otherwise		

sub MatchingTFErrorResult 

	{

	my $aFail = shift;

	my $aReferenceLogContents = shift;

	my $refContents = $$aReferenceLogContents;

	if (not $refContents =~ s/Test[\s]+Result[\s]+for[\s]+[\S]+:$aFail[\s]+is[\s]+([\_|\-|\S]+)[\s]*\<\/font\>//)

		{

		return 0;

		}

	if (($1 eq "PASS") || ($1 eq "INCONCLUSIVE"))

		{

		return 0;

		}

	return 1;

	}	

# N.B. VERY IMPORTANT that the log file is passed by reference.  Core conf scripts can include numerous

# different tests that use the same test name so to avoid false positives from this function the 

# substitution done in the comparison MUST affect the caller's copy of the log file.

sub MatchingCoreConfErrorResult

	{	

	my $aFail = shift;

	my $aReferenceLogContents = shift;

	my $refContents = $$aReferenceLogContents;

	if ($refContents =~ s/\*\*\*[\s]*$aFail[\s]*FAILED//)