// Copyright (c) 1999-2009 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:

//

/**

 @file

*/

#include <cfshared.h>

#include <c32root.h>

#include <sacls.h>

#include <e32math.h>

#include "TE_smsprtbase.h"

/**

	Preamble for all CSmsPrtTestStep

*/

TVerdict CSmsPrtTestStep::doTestStepPreambleL()

	{

	//base class preamble - marks the heap

	CSMSTestSteps::doTestStepPreambleL();

	iScheduler = new(ELeave) CActiveScheduler;

	CActiveScheduler::Install(iScheduler);

    TRAPD(ret, ParseSettingsFromFileL());

	if (ret != KErrNone)

		{

		INFO_PRINTF2(_L("ParseSettingsFromFileL [err=%d]"), ret);

		}

	iSmsStackTestUtils = CSmsStackTestUtils::NewL(this,  iFs);

	return TestStepResult() ;

	}

/**

	Cleanup SmsStackTestUtils, close the filer server session and delete the scheduler

*/

TVerdict CSmsPrtTestStep::doTestStepPostambleL()

	{

	delete iSmsStackTestUtils;

	iSmsStackTestUtils = NULL;

	delete iScheduler;

	iScheduler = NULL;

	//base class postamble - unmarks the heap

	CSMSTestSteps::doTestStepPostambleL();

	//DoESockMemoryLeakTestL();

 	return CSMSTestSteps::doTestStepPostambleL() ;

	} // CSmsPrtTestStep::doTestStepPostambleL

void CSmsPrtTestStep::DoESockMemoryLeakTestL()

	{

	//

	// Find the current number of leaked cells in ESock...

	//

	TInt  ret, startLeakCounter;

	ret = RProperty::Get(KUidCommsProcess, KUidCommsModuleLeakCounter, startLeakCounter);

	if (ret == KErrNotFound)

		{

		// No variable to monitor, ESock is probably not in debug mode.

		return;

		}

	else

		{

		TESTL(ret == KErrNone);

		}

	//

	// Connect to Rootserver...

	//

	RRootServ  rootserver;

	User::LeaveIfError(rootserver.Connect());

	CleanupClosePushL(rootserver);

	//

	// Shutdown all the ESock CPMs gracefully...

	//

	TRSIter  iter;

	TCFModuleName  modName;

	TRSModuleInfo  modInfo;

	TRequestStatus  statusArray[16];

	TInt  statusCount = 0;

	while (rootserver.EnumerateModules(iter, modName) == KErrNone)

		{

		if (rootserver.GetModuleInfo(modName, modInfo) == KErrNone  &&

		    modInfo.iParams.iDll.MatchF(_L("*ESOCKSVR.DLL")) >= 0)

			{

			rootserver.UnloadCpm(statusArray[statusCount++], modInfo.iParams.iName,

			                     EGraceful);

			}

		}

	while (statusCount > 0)

		{

		statusCount--;

		User::WaitForRequest(statusArray[statusCount]);

		TEST(statusArray[statusCount] == KErrNone);

		}

	//

	// Close Rootserver session...

	//

	CleanupStack::PopAndDestroy(1, &rootserver);

	//

	// Get the latest number of leaked cells in ESock...

	//

	TInt  finalLeakCounter;

	ret = RProperty::Get(KUidCommsProcess, KUidCommsModuleLeakCounter, finalLeakCounter);

	TESTL(ret == KErrNone);

	if (finalLeakCounter > startLeakCounter)

		{

		INFO_PRINTF1(_L("<font size=2 color=FF0000><B>A memory leak has been detected inside ESock - Check SMS Stack!</B></font>"));

		TEST(finalLeakCounter == startLeakCounter);

		}

	//

	// Restart C32...

	//

	_LIT(KDummyCMI, "");

	WarmBootC32(KDummyCMI);

	} // CSmsPrtTestStep::DoESockMemoryLeakTestL

/**

 *	Pre-test step function for Encoding tests.

 * 

 *  @return EPass or EFail verdict.

 */

TVerdict CSmsPrtEncodingTestStep::doTestStepPreambleL()

	{

	CSmsPrtTestStep::doTestStepPreambleL();

	iTestAlphabet = CSmsPrtTestAlphabet::NewL();

	return TestStepResult() ;

	} // CSmsPrtEncodingTestStep::doTestStepPreambleL

/**

 *	Post-test step function for Encoding tests.

 * 

 *  @return EPass or EFail verdict.

 */

TVerdict CSmsPrtEncodingTestStep::doTestStepPostambleL()

	{

	delete iTestAlphabet;

	iTestAlphabet = NULL;

    iCharSets.Reset();

    iAdditionalCharSets.Reset();

 	return CSmsPrtTestStep::doTestStepPostambleL();

 	} // CSmsPrtEncodingTestStep::doTestStepPostambleL

/**

 *  Computes the expected number of PDUs and expected number of free characters

 *  (User Data Units) in the last PDU. This is computed from the number of

 *  octets in the message.

 * 

 *  @param aOctetsCount                   Number of octets.

 *  @param aAlphabet                      Data Coding Scheme in use.

 *  @param aExpectedPDUs                  Returned expected PDUs.

 *  @param aExpectedFreeUDUnitsInLastPDU  Returned expected free UDUnits.

 */

void CSmsPrtEncodingTestStep::GetExpectedPDUCountAndUDUnitsFreeL(TInt aOctetsCount, 

			                                                     TSmsDataCodingScheme::TSmsAlphabet aAlphabet,

			                                                     TSmsEncoding aEncodingExpected,

			                                                     TInt& aExpectedPDUs,

				                                                 TInt& aExpectedFreeUDUnitsInLastPDU) const

	{

	//

	// Calculate the IEs that will be added...

	//

	TInt  expectedIESize = 0;

	if (aAlphabet == TSmsDataCodingScheme::ESmsAlphabet7Bit)

		{

		if (aEncodingExpected == ESmsEncodingTurkishSingleShift  ||

		    aEncodingExpected == ESmsEncodingTurkishLockingShift  ||

		    aEncodingExpected == ESmsEncodingSpanishSingleShift  ||

		    aEncodingExpected == ESmsEncodingPortugueseSingleShift  ||

		    aEncodingExpected == ESmsEncodingPortugueseLockingShift)

			{

			// National Single Shift or Locking Shift is 3 bytes each.

			if (expectedIESize == 0)

				{

				expectedIESize += 3 + 1; // Extra 1 byte for the UDHL per PDU...

				}

			else

				{

				expectedIESize += 3;

				}

			}

		else if (aEncodingExpected == ESmsEncodingTurkishLockingAndSingleShift  ||

		         aEncodingExpected == ESmsEncodingPortugueseLockingAndSingleShift)

			{

			// National Single Shift and Locking Shift costs 6 bytes total.

			if (expectedIESize == 0)

				{

				expectedIESize += 6 + 1; // Extra 1 byte for the UDHL per PDU...

				}

			else

				{

				expectedIESize += 6;

				}

			}

		}

	if ((aAlphabet == TSmsDataCodingScheme::ESmsAlphabet7Bit  &&  (aOctetsCount + ((expectedIESize*8)+6)/7) > 160)  ||

		(aAlphabet != TSmsDataCodingScheme::ESmsAlphabet7Bit  &&  (aOctetsCount + expectedIESize) > 140))

		{

		// Concatenated IE is 5 bytes...

		if (expectedIESize == 0)

			{

			expectedIESize += 5 + 1; // Extra 1 byte for the UDHL per PDU...

			}

		else

			{

			expectedIESize += 5;

			}

		}

	//

	// Now compute the PDUs required.

	//

	if (aAlphabet == TSmsDataCodingScheme::ESmsAlphabet7Bit)

		{

		TInt  octetsPerPDU    = 160 - ((expectedIESize*8)+6)/7;

		TInt  completePDUs    = aOctetsCount / octetsPerPDU;

		TInt  octetsInLastPDU = aOctetsCount % octetsPerPDU;

		aExpectedPDUs                 = completePDUs + (octetsInLastPDU > 0);

		aExpectedFreeUDUnitsInLastPDU = octetsPerPDU - octetsInLastPDU;

		if (octetsInLastPDU == 0)

			{

			aExpectedFreeUDUnitsInLastPDU = 0;

			}

		}

	else if (aAlphabet == TSmsDataCodingScheme::ESmsAlphabet8Bit  ||

			 aAlphabet == TSmsDataCodingScheme::ESmsAlphabetUCS2)

		{

		TInt  octetsPerPDU    = 140 - expectedIESize;

		TInt  completePDUs    = aOctetsCount / octetsPerPDU;

		TInt  octetsInLastPDU = aOctetsCount % octetsPerPDU;

		aExpectedPDUs                 = completePDUs + (octetsInLastPDU > 0);

		aExpectedFreeUDUnitsInLastPDU = octetsPerPDU - octetsInLastPDU;

		if (octetsInLastPDU == 0)

			{

			aExpectedFreeUDUnitsInLastPDU = 0;

			}

		}

	else

		{

		User::Leave(KErrNotSupported);

		}

	} // CSmsPrtEncodingTestStep::GetExpectedPDUCountAndUDUnitsFreeL

/**

 *  Computes the expected number of supported characters in a string based

 *  on the old API behaviour.

 * 

 *  @param aDes                             String to test.

 *  @param aAlphabet                        Data Coding Scheme in use.

 *  @param aExpectedUnconvertibleChars      Returned expected unconvertible characters.

 *  @param aExpectedFirstUnconvertibleChar  Returned first unconvertible character.

 */

void CSmsPrtEncodingTestStep::GetExpectedEncodingInfoL(TDesC& aDes,

													   TSmsDataCodingScheme::TSmsAlphabet aAlphabet,

				                                       TInt& aExpectedUnconvertibleChars,

													   TInt& aExpectedFirstUnconvertibleChar) const

	{

	aExpectedUnconvertibleChars     = 0;

	aExpectedFirstUnconvertibleChar = aDes.Length();

	if (aAlphabet == TSmsDataCodingScheme::ESmsAlphabet7Bit)

		{

		for (TInt pos = aDes.Length()-1;  pos >= 0;  pos--)

			{

			// For each character in the descriptor check for support in the standard tables

			if (iTestAlphabet->IsCharListedInCharacterSetL(KCharacterSetStandard7bitGSM, aDes[pos]) == EFalse  &&

				iTestAlphabet->IsCharListedInCharacterSetL(KCharacterSetStandard7bitGSMShift, aDes[pos]) == EFalse)

				{

				aExpectedUnconvertibleChars++;

				aExpectedFirstUnconvertibleChar = pos;

				}

			}

		}

	else if (aAlphabet == TSmsDataCodingScheme::ESmsAlphabet8Bit)

		{

		for (TInt pos = aDes.Length()-1;  pos >= 0;  pos--)

			{

			if (aDes[pos] > 0xff)

				{

				aExpectedUnconvertibleChars++;

				aExpectedFirstUnconvertibleChar = pos;

				}

			}

		}

	else if (aAlphabet == TSmsDataCodingScheme::ESmsAlphabetUCS2)

		{

		// NOP, everything accepted!

		}

	else

		{

		User::Leave(KErrNotSupported);

		}

	} // CSmsPrtEncodingTestStep::GetExpectedEncodingInfoL

/**

 *  Computes the expected number of supported characters in a string based

 *  on the new API behaviour.

 * 

 *  @param aDes                               String to test.

 *  @param aAlphabet                          Data Coding Scheme in use.

 *  @param aEncoding                          Alternative 7bit Encoding (if used).

 *  @param aExpectedUnconvertibleChars        Returned expected unconvertible characters.

 *  @param aExpectedDowngradedChars           Returned expected downgraded characters.

 *  @param aExpectedAlternativeEncodingChars  Returned expected alternative encoding characters.

 *  @param aExpectedFirstUnconvertibleChar    Returned first unconvertible character.

 */

void CSmsPrtEncodingTestStep::GetExpectedEncodingInfoL(TDesC& aDes,

													   TSmsDataCodingScheme::TSmsAlphabet aAlphabet,

													   TSmsEncoding aEncoding,

				                                       TInt& aExpectedUnconvertibleChars,

				                                       TInt& aExpectedDowngradedChars,

				                                       TInt& aExpectedAlternativeEncodingChars,

													   TInt& aExpectedFirstUnconvertibleChar) const

	{

	aExpectedUnconvertibleChars       = 0;

	aExpectedDowngradedChars          = 0;

	aExpectedAlternativeEncodingChars = 0;

	aExpectedFirstUnconvertibleChar   = aDes.Length();

	if (aAlphabet == TSmsDataCodingScheme::ESmsAlphabet7Bit)

		{

		for (TInt pos = aDes.Length()-1;  pos >= 0;  pos--)

			{

			if (iTestAlphabet->IsCharListedInCharacterSetL(KCharacterSetStandard7bitGSM, aDes[pos]) == EFalse  &&

				iTestAlphabet->IsCharListedInCharacterSetL(KCharacterSetStandard7bitGSMShift, aDes[pos]) == EFalse)

				{

				// The test design tries to use non-overlapping character sets to make 

				// Encoding / Downgrading tests easier to write - thus KCharacterSetTurkish7bitGSMLocking

				// is chosen not to include any characters in KCharacterSetStandard7bitGSMShift

				if ((aEncoding == ESmsEncodingTurkishLockingShift  ||

					 aEncoding == ESmsEncodingTurkishLockingAndSingleShift)  &&

					iTestAlphabet->IsCharListedInCharacterSetL(KCharacterSetTurkish7bitGSMLocking, aDes[pos]))

					{

					aExpectedAlternativeEncodingChars++;

					if (iTestAlphabet->IsCharDowngradedByCharacterSetL(KCharacterSetTurkish7bitGSMLocking, aDes[pos]))

						{

						aExpectedDowngradedChars++;

						}

					}

                else if ((aEncoding == ESmsEncodingTurkishSingleShift  ||

                          aEncoding == ESmsEncodingTurkishLockingAndSingleShift)  &&

                          iTestAlphabet->IsCharListedInCharacterSetL(KCharacterSetTurkish7bitGSMShift, aDes[pos]))

                    {

                    aExpectedAlternativeEncodingChars++;

                    if (iTestAlphabet->IsCharDowngradedByCharacterSetL(KCharacterSetTurkish7bitGSMShift, aDes[pos]))

                        {

                        aExpectedDowngradedChars++;

                        }

                    }

                else if (aEncoding == ESmsEncodingSpanishSingleShift  &&

                          iTestAlphabet->IsCharListedInCharacterSetL(KCharacterSetSpanish7bitGSMShift, aDes[pos]))

                    {

                    aExpectedAlternativeEncodingChars++;

                    if (iTestAlphabet->IsCharDowngradedByCharacterSetL(KCharacterSetSpanish7bitGSMShift, aDes[pos]))

                        {

                        aExpectedDowngradedChars++;

                        }

                    }

                else if ((aEncoding == ESmsEncodingPortugueseLockingShift  ||

                     aEncoding == ESmsEncodingPortugueseLockingAndSingleShift)  &&

                    iTestAlphabet->IsCharListedInCharacterSetL(KCharacterSetPortuguese7bitGSMLocking, aDes[pos]))

                    {

                    aExpectedAlternativeEncodingChars++;

                    if (iTestAlphabet->IsCharDowngradedByCharacterSetL(KCharacterSetPortuguese7bitGSMLocking, aDes[pos]))

                        {

                        aExpectedDowngradedChars++;

                        }

                    }

                else if ((aEncoding == ESmsEncodingPortugueseSingleShift  ||

                          aEncoding == ESmsEncodingPortugueseLockingAndSingleShift)  &&

                          iTestAlphabet->IsCharListedInCharacterSetL(KCharacterSetPortuguese7bitGSMShift, aDes[pos]))

                    {

                    aExpectedAlternativeEncodingChars++;

                    if (iTestAlphabet->IsCharDowngradedByCharacterSetL(KCharacterSetPortuguese7bitGSMShift, aDes[pos]))

                        {

                        aExpectedDowngradedChars++;

                        }

                    }				

				else if (iTestAlphabet->IsCharDowngradedByCharacterSetL(KCharacterSetDowngrading7bitGSM, aDes[pos])  ||

					     iTestAlphabet->IsCharDowngradedByCharacterSetL(KCharacterSetDowngrading7bitGSMExtended, aDes[pos]))

					{

					aExpectedDowngradedChars++;

					}

				else

					{

					aExpectedUnconvertibleChars++;

					aExpectedFirstUnconvertibleChar = pos;

					}

				}

			else if (iTestAlphabet->IsCharDowngradedByCharacterSetL(KCharacterSetStandard7bitGSM, aDes[pos])  ||

					 iTestAlphabet->IsCharDowngradedByCharacterSetL(KCharacterSetStandard7bitGSMShift, aDes[pos]))

				{

				aExpectedDowngradedChars++;

				}

			}

		}

	else if (aAlphabet == TSmsDataCodingScheme::ESmsAlphabet8Bit)

		{

		for (TInt pos = aDes.Length()-1;  pos >= 0;  pos--)

			{

			if (aDes[pos] > 0xff)

				{

				aExpectedUnconvertibleChars++;

				aExpectedFirstUnconvertibleChar = pos;

				}

			}

		}

	else if (aAlphabet == TSmsDataCodingScheme::ESmsAlphabetUCS2)

		{

		// NOP, everything accepted!

		}

	else

		{

		User::Leave(KErrNotSupported);

		}

	} // CSmsPrtEncodingTestStep::GetExpectedEncodingInfoL

void CSmsPrtEncodingTestStep::DoEncodingTestL(RSocket aSocket,

                                              const TDesC& aTestName,

                                              TInt aTestSequences,

                                              RArray<TPtrC>& aTestCharSetNames,

                                              TSmsDataCodingScheme::TSmsAlphabet aAlphabet,

                                              TSmsEncoding aEncodingToUse,

                                              TSmsEncoding aEncodingExpected)

    {

    //

    // Work out the number of characters to test with...

    //

    TInt  charSetSize = 0;

    TInt countTestCharSetNames = aTestCharSetNames.Count();

    for (TInt charSet = 0;  charSet < countTestCharSetNames;  ++charSet)

        {

        TInt  charactersInCharSet = iTestAlphabet->GetCharacterSetSizeL(aTestCharSetNames[charSet]);

        charSetSize += charactersInCharSet;

        }

    TInt  characters    = charSetSize * aTestSequences;

    TInt additionalTestCharacters = 0; 

    // perform the test

    DoEncodingTestL(aSocket, aTestName, characters, aTestCharSetNames,

                    additionalTestCharacters, aTestCharSetNames,

                    aAlphabet, aEncodingToUse, aEncodingExpected);

    }

void CSmsPrtEncodingTestStep::DoEncodingTestL(RSocket aSocket,

                                              const TDesC& /*aTestName*/,

                                              TInt aTestCharacters,

                                              RArray<TPtrC>& aTestCharSetNames,

                                              TInt aAdditionalTestCharacters,

                                              RArray<TPtrC>& aAdditionalTestCharSetNames,

                                              TSmsDataCodingScheme::TSmsAlphabet aAlphabet,

                                              TSmsEncoding aEncodingToUse,

                                              TSmsEncoding aEncodingExpected)

    {          

	//

	// Display the test name and details...

	//

    TInt countTestCharSetNames = aTestCharSetNames.Count();

    for (TInt charSet = 0;  charSet < countTestCharSetNames;  ++charSet)

        {

        TInt  charactersInCharSet = iTestAlphabet->GetCharacterSetSizeL(aTestCharSetNames[charSet]);

        INFO_PRINTF3(_L("  Using character set \"%S\" which contains %d characters..."),

                     &aTestCharSetNames[charSet], charactersInCharSet);

        }

    INFO_PRINTF2(_L("Testing encode functions starting with %d characters."), aTestCharacters);

    TInt countAdditionalTestCharSetNames = aAdditionalTestCharSetNames.Count();

    for (TInt charSet = 0;  charSet < countAdditionalTestCharSetNames;  ++charSet)

        {

        TInt  charactersInCharSet = iTestAlphabet->GetCharacterSetSizeL(aAdditionalTestCharSetNames[charSet]);

        INFO_PRINTF3(_L("  Using additional character set \"%S\" which contains %d characters..."),

                     &aAdditionalTestCharSetNames[charSet], charactersInCharSet);

        }

	INFO_PRINTF2(_L("Total test length is %d characters."), aTestCharacters + aAdditionalTestCharacters);

	//

	// Build a message with all the characters in and monitor the Encoding

	// Info values. Allow a few extra bytes (e.g. the number of character sets

	// used) to allow for the fact that we add aTestCharSetNames.Count()

	// characters at a time, and therefore it may overrun by this amount.