/*

* Copyright (c) 2002 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:  ?Description

*

*/

/* Changed by Vaibhav - 13Aug07 for Removing CodeScanner Warnings - High/medium */

// INCLUDE FILES

#include <e32math.h>

#include "BCSmsUtilitiesTest.h"

#include <gsmunmspacemobmsg.h>

#include <S32file.h>

#include <e32cons.h>

#include <txtrich.h>

#include <gsmuelem.h>

#define KTimeStampSize 32

_LIT(KTestNativeChar, "SmsGsmUtilities");

_LIT8(KTestNativeChar8, "SmsGsmUtilities");

_LIT8(KTestInfo8, "ABCDEFGH");

_LIT8(KTestCommandData8, "CommandData");

_LIT(KTestBuffer1, "ABCDEFGHIJKLMNOPQRSTUVWX");

// ============================= LOCAL FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// Create_Console

// Creates a new Console Window

// -----------------------------------------------------------------------------

LOCAL_C CConsoleBase* Create_ConsoleL(const TDesC& title)

	{

    CConsoleBase* console;

    console = Console::NewL(title,TSize( KConsFullScreen, KConsFullScreen));

	CleanupStack::PushL( console );

	return 	console;

	}

// -----------------------------------------------------------------------------

// Print

// Prints the result onto screen

// -----------------------------------------------------------------------------

LOCAL_C void Print(CConsoleBase* base, TInt result, const TDesC& text)

	{

	base->Printf(text);

	if( result == KErrNone)

		{

		base->Printf(_L(" passed\n"));

		}

	else

		{

		base->Printf(_L("::Error code %d\n"), result);

		}

	}

// -----------------------------------------------------------------------------

// Remove_Console

// Deletes a new Console Window

// -----------------------------------------------------------------------------

LOCAL_C void Remove_Console(CConsoleBase* base)

	{

	//base->Getch();

	CleanupStack::PopAndDestroy(base);

	}

void Check(TInt aValue, TInt aExpected )

	{

	if(aValue != aExpected)

		{

		RDebug::Print(_L("*** Expected value: %d, got: %d\r\n"), aExpected, aValue);

		__ASSERT_ALWAYS(aValue != aExpected, User::Panic(_L("Active object Error"), 1));

		}

	}

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CBCSmsUtilitiesTest::Case

// Returns a test case by number.

//

// This function contains an array of all available test cases 

// i.e pair of case name and test function. If case specified by parameter

// aCaseNumber is found from array, then that item is returned.

// 

// The reason for this rather complicated function is to specify all the

// test cases only in one place. It is not necessary to understand how

// function pointers to class member functions works when adding new test

// cases. See function body for instructions how to add new test case.

// -----------------------------------------------------------------------------

//

const TCaseInfo CBCSmsUtilitiesTest::Case ( 

    const TInt aCaseNumber ) const 

     {

     static TCaseInfoInternal const KCases[] =

        {

        // To add new test cases, add new items to this array

        ENTRY( "CSmsAlphabetConverter", CBCSmsUtilitiesTest::TestSmsAlphabetConverterL ),

        ENTRY( "CSmsBuffer", CBCSmsUtilitiesTest::TestSmsBufferL ),

        ENTRY( "CSmsCommand", CBCSmsUtilitiesTest::TestSmsCommandL ),

        ENTRY( "CSmsDeliver", CBCSmsUtilitiesTest::TestSmsDeliverL ),

        ENTRY( "CSmsDeliverReport", CBCSmsUtilitiesTest::TestSmsDeliverReportL ),

        ENTRY( "CSmsEditorBuffer", CBCSmsUtilitiesTest::TestSmsEditorBufferL ),

        ENTRY( "CSmsInformationElement", CBCSmsUtilitiesTest::TestSmsInformationElementL ),

        ENTRY( "CSmsMessage", CBCSmsUtilitiesTest::TestSmsMessageL ),

        ENTRY( "CSmsPDU", CBCSmsUtilitiesTest::TestSmsPDUL ),

        ENTRY( "CSmsStatusReport", CBCSmsUtilitiesTest::TestSmsStatusReportL ),

        ENTRY( "CSmsSubmit", CBCSmsUtilitiesTest::TestSmsSubmitL ),

        ENTRY( "CSmsSubmitReport", CBCSmsUtilitiesTest::TestSmsSubmitReportL ),

        ENTRY( "CSmsUserData", CBCSmsUtilitiesTest::TestSmsUserDataL ),

         };

    // Verify that case number is valid

    if( (TUint) aCaseNumber >= sizeof( KCases ) / 

                               sizeof( TCaseInfoInternal ) )

        {

        // Invalid case, construct empty object

        TCaseInfo null( (const TText*) L"" );

        null.iMethod = NULL;

        null.iIsOOMTest = EFalse;

        null.iFirstMemoryAllocation = 0;

        null.iLastMemoryAllocation = 0;

        return null;

        } 

    // Construct TCaseInfo object and return it

    TCaseInfo tmp ( KCases[ aCaseNumber ].iCaseName );

    tmp.iMethod = KCases[ aCaseNumber ].iMethod;

    tmp.iIsOOMTest = KCases[ aCaseNumber ].iIsOOMTest;

    tmp.iFirstMemoryAllocation = KCases[ aCaseNumber ].iFirstMemoryAllocation;

    tmp.iLastMemoryAllocation = KCases[ aCaseNumber ].iLastMemoryAllocation;

    return tmp;

    }

// -----------------------------------------------------------------------------

// TestGetAlphabet

// Gets the coding scheme alphabet

// -----------------------------------------------------------------------------

//

LOCAL_C TInt TestGetAlphabet( CStifLogger* aLog, CSmsAlphabetConverter& aAlphabetConv)

	{

	aLog->Log(_L("---------------------------------------------"));

	aLog->Log(_L("Calling Alphabet()"));

	TInt result = KErrNone;

	//inline TSmsDataCodingScheme::TSmsAlphabet CSmsAlphabetConverter::Alphabet() const

	TSmsDataCodingScheme::TSmsAlphabet alphabet = aAlphabetConv.Alphabet();

	if( alphabet == TSmsDataCodingScheme::ESmsAlphabet8Bit )

		{

		aLog->Log(_L("Alphabet() Completed"));

		aLog->Log(_L("Alphabet fetched"));

		aLog->Log(_L("Get alphabet == PASS"));

		}

	else

		{

		result = KErrGeneral;

		aLog->Log(_L("Get alphabet == FAIL"));

		}

	return result;

	}

// -----------------------------------------------------------------------------

// TestConvertFromNative

// Converts from the native character set to 

// unpacked user data elements of the desired character set.

// -----------------------------------------------------------------------------

//

LOCAL_C TInt TestConvertFromNative( CStifLogger* aLog, CSmsAlphabetConverter& aAlphabetConv)

	{

	aLog->Log(_L("---------------------------------------------"));

	aLog->Log(_L("Calling ConvertFromNativeL()"));

	TBufC<24> nativeChar(KTestNativeChar);

	TBufC8<24> UDElements(KTestNativeChar8);

	//IMPORT_C TPtrC8 ConvertFromNativeL(const TDesC& aNativeCharacters);

	TPtrC8 convChar;

	TRAPD( result, convChar.Set(aAlphabetConv.ConvertFromNativeL(nativeChar))) ;

	TPtrC8 UDElementsPtr(UDElements);

	if(convChar.Compare(UDElementsPtr))

		{

		result = KErrGeneral;

		aLog->Log(_L("Convert from native == FAIL"));	

		}

	else

		{

		aLog->Log(_L("ConvertFromNativeL() Completed"));

		aLog->Log(_L("Conversion successfully performoded"));

		aLog->Log(_L("Convert from native == PASS"));

		}

	return result;

	}

LOCAL_C TInt TestConvertFromNative2L( CStifLogger* aLog, CSmsAlphabetConverter& aAlphabetConv)

	{

	aLog->Log(_L("---------------------------------------------"));

	aLog->Log(_L("Calling ConvertFromNative2L()"));

	TBufC<24> nativeChar(KTestNativeChar);

	TBufC8<24> UDElements(KTestNativeChar8);

	TInt numUnconvertibleChars;

	TInt numDowngradedChars;

	TPtrC8 convChar;

	TRAPD( result, convChar.Set(aAlphabetConv.ConvertFromNativeL(nativeChar,ESmsEncodingNone,numUnconvertibleChars,numDowngradedChars ))) ;

	TPtrC8 UDElementsPtr(UDElements);

	if(convChar.Compare(UDElementsPtr))

		{

		result = KErrGeneral;

		aLog->Log(_L("Convert from native2 == FAIL"));	

		}

	else

		{

		aLog->Log(_L("ConvertFromNative2L() Completed"));

		aLog->Log(_L("Conversion successfully performoded"));

		aLog->Log(_L("Convert from native2 == PASS"));

		}

	return result;

	}	

// -----------------------------------------------------------------------------

// TestConvertToNative

// Converts the user data elements of the specified character set to 

// the native character set.

// -----------------------------------------------------------------------------

//

LOCAL_C TInt TestConvertToNative( CStifLogger* aLog, CSmsAlphabetConverter& aAlphabetConv)

	{

	aLog->Log(_L("---------------------------------------------"));

	aLog->Log(_L("Calling ConvertToNativeL()"));

	TBufC<24> nativeChar(KTestNativeChar);

	TBufC8<24> UDElements(KTestNativeChar8);

	//IMPORT_C TPtrC ConvertToNativeL(const TDesC8& aUDElements);

	TPtrC convChar;

	TRAPD( result, convChar.Set(aAlphabetConv.ConvertToNativeL(UDElements)));

	TBufC<24> nativeCharPtr(nativeChar);

	if(convChar.Compare(nativeCharPtr))

		{

		result = KErrGeneral;

		aLog->Log(_L("Convert To native == FAIL"));	

		}

	else

		{

		aLog->Log(_L("ConvertToNativeL() Completed"));

		aLog->Log(_L("Conversion successfully performoded"));

		aLog->Log(_L("Convert To native == PASS"));

		}

	return result;

	}

LOCAL_C TInt TestConvertToNative2L( CStifLogger* aLog, CSmsAlphabetConverter& aAlphabetConv)

	{

	aLog->Log(_L("---------------------------------------------"));

	aLog->Log(_L("Calling ConvertToNative2L()"));

	TBufC<24> nativeChar(KTestNativeChar);

	TBufC8<24> UDElements(KTestNativeChar8);

	TPtrC convChar;

	TRAPD( result, convChar.Set(aAlphabetConv.ConvertToNativeL(UDElements,ESmsEncodingNone )));

	TBufC<24> nativeCharPtr(nativeChar);

	if(convChar.Compare(nativeCharPtr))

		{

		result = KErrGeneral;

		aLog->Log(_L("Convert To native2 == FAIL"));	

		}

	else

		{

		aLog->Log(_L("ConvertToNative2L() Completed"));

		aLog->Log(_L("Conversion successfully performoded"));

		aLog->Log(_L("Convert To native2 == PASS"));

		}

	return result;

	}	

// -----------------------------------------------------------------------------

// TestResetUnconvertedNativeCharacters

// Resets the unconverted native character buffer

// -----------------------------------------------------------------------------

//

LOCAL_C TInt TestResetUnconvertedNativeCharacters( CStifLogger* aLog, CSmsAlphabetConverter& aAlphabetConv)

	{

	aLog->Log(_L("---------------------------------------------"));

	aLog->Log(_L("Calling ResetUnconvertedNativeCharacters()"));

	TInt result = KErrNone;

	//inline void ResetUnconvertedNativeCharacters();

	aAlphabetConv.ResetUnconvertedNativeCharacters();

	aLog->Log(_L("ResetUnconvertedNativeCharacters() Completed"));

	aLog->Log(_L("Reset performed successfully"));

	aLog->Log(_L("Reset unconverted native characters == PASS"));

	return result;

	}

// -----------------------------------------------------------------------------

// TestResetUnconvertedUDElements

// Resets the unconverted user data elements buffer

// -----------------------------------------------------------------------------

//

LOCAL_C TInt TestResetUnconvertedUDElements( CStifLogger* aLog, CSmsAlphabetConverter& aAlphabetConv)

	{

	aLog->Log(_L("---------------------------------------------"));

	aLog->Log(_L("Calling ResetUnconvertedUDElements()"));

	TInt result = KErrNone;

	//inline void ResetUnconvertedUDElements();

	aAlphabetConv.ResetUnconvertedUDElements();

	aLog->Log(_L("ResetUnconvertedUDElements() Completed"));

	aLog->Log(_L("Reset performed successfully"));

	aLog->Log(_L("Reset unconverted UD Elements == PASS"));

	return result;

	}

// -----------------------------------------------------------------------------

// TestUnconvertedNativeCharacters

// Gets the unconverted native characters

// -----------------------------------------------------------------------------

//

LOCAL_C TInt TestUnconvertedNativeCharacters( CStifLogger* aLog, CSmsAlphabetConverter& aAlphabetConv)

	{

	aLog->Log(_L("---------------------------------------------"));

	aLog->Log(_L("Calling UnconvertedNativeCharacters()"));

	TInt result = KErrNone;

	//inline TPtrC UnconvertedNativeCharacters();

	TPtrC nativeCharPtr( aAlphabetConv.UnconvertedNativeCharacters() );

	aLog->Log(_L("UnconvertedNativeCharacters() Completed"));

	if(nativeCharPtr != KNullDesC )

		aLog->Log(_L("Result data:Characters: %s"), nativeCharPtr.Ptr());

	else

		aLog->Log(_L("Result data:Characters: NULL "));

	aLog->Log(_L("Get unconverted native characters == PASS"));

	return result;

	}

// -----------------------------------------------------------------------------

// TestUnconvertedUDElements

// Gets the unconverted user data elements

// -----------------------------------------------------------------------------

//

LOCAL_C TInt TestUnconvertedUDElements( CStifLogger* aLog, CSmsAlphabetConverter& aAlphabetConv)

	{

	aLog->Log(_L("---------------------------------------------"));

	aLog->Log(_L("Calling UnconvertedUDElements()"));

	TInt result = KErrNone;

	//inline TPtrC8 UnconvertedUDElements();

	TPtrC8 UDElementsPtr( aAlphabetConv.UnconvertedUDElements());

	aLog->Log(_L("UnconvertedUDElements() Completed"));

	if( UDElementsPtr!= KNullDesC8 )

		aLog->Log(_L("Result data:Characters: %s"), UDElementsPtr.Ptr());

	else

		aLog->Log(_L("Result data:Characters: NULL"));

	aLog->Log(_L("Get unconverted UD Elements == PASS"));

	return result;

	}

// -----------------------------------------------------------------------------

// TestDelete

// Deletes data from the buffer

// -----------------------------------------------------------------------------

//

LOCAL_C TInt TestDelete( CStifLogger* aLog, CSmsBuffer& aBuffer)

	{

	aLog->Log(_L("---------------------------------------------"));

	aLog->Log(_L("Calling DeleteL()"));

	TInt position = 2;

	TInt length = 2;

	//IMPORT_C void DeleteL(TInt aPos,TInt aLength);

	TRAPD( result, aBuffer.DeleteL( position, length));

	if( result == KErrNone )

		{

		aLog->Log(_L("DeleteL() Completed"));

		aLog->Log(_L("Data successfully deleted"));

		aLog->Log(_L("Delete == PASS"));

		}

	else

		aLog->Log(_L("Delete == FAIL"));

	return result;

	}

// -----------------------------------------------------------------------------

// TestReset

// Resets the buffer

// -----------------------------------------------------------------------------

//

LOCAL_C TInt TestReset( CStifLogger* aLog, CSmsBuffer& aBuffer)

	{

	aLog->Log(_L("---------------------------------------------"));

	aLog->Log(_L("Calling Reset()"));

	TInt result = KErrNone;

	//IMPORT_C void Reset();

	aBuffer.Reset();

	aLog->Log(_L("Reset() Completed"));

	aLog->Log(_L("Data successfully reseted"));

	aLog->Log(_L("Reset == PASS"));

	return result;

	}

// -----------------------------------------------------------------------------

// TestExtract

// Extracts buffer data to a descriptor

// -----------------------------------------------------------------------------

//

LOCAL_C TInt TestExtract( CStifLogger* aLog, CSmsBuffer& aBuffer)

	{

	aLog->Log(_L("---------------------------------------------"));

	aLog->Log(_L("Calling Extract()"));

	TInt result = KErrNone;

	TBuf<24> buffer;

	TInt position = 2;

	TInt length = 6;

	//IMPORT_C void Extract(TDes& aBuf,TInt aPos,TInt aLength) const;

	aBuffer.Extract(buffer, position, length);

	aLog->Log(_L("Extract() Completed"));

	aLog->Log(_L("Data successfully extracted"));

	aLog->Log(_L("Extract == PASS"));

	return result;

	}

// -----------------------------------------------------------------------------

// TestInsert

// Inserts data into the buffer

// -----------------------------------------------------------------------------

//

LOCAL_C TInt TestInsert( CStifLogger* aLog, CSmsBuffer& aBuffer)

	{

	aLog->Log(_L("---------------------------------------------"));

	aLog->Log(_L("Calling InsertL()"));

	TBufC<24> buffer(KTestBuffer1);

	TInt position = 0;

	//IMPORT_C void InsertL(TInt aPos,const TDesC& aBuf);

	TRAPD( result, aBuffer.InsertL(position, buffer));

	if( result == KErrNone )

		{

		aLog->Log(_L("InsertL() Completed"));

		aLog->Log(_L("Data successfully Inserted"));

		aLog->Log(_L("InsertL == PASS"));

		}

	else

		aLog->Log(_L("InsertL == FAIL"));

	return result;

	}

// -----------------------------------------------------------------------------

// TestGetLength

// Gets the amount of space currently used in the buffer.

// -----------------------------------------------------------------------------

//

LOCAL_C TInt TestGetLength( CStifLogger* aLog, CSmsBuffer& aBuffer)

	{

	aLog->Log(_L("---------------------------------------------"));

	aLog->Log(_L("Calling Length()"));

	TInt result = KErrNone;

	//IMPORT_C TInt Length() const;

	TInt length = aBuffer.Length();

	if(length == 22) 

		{

		aLog->Log(_L("Length() Completed"));

		aLog->Log(_L("Result data: Length: %d"), length);

		aLog->Log(_L("Length == PASS"));	

		}

	else

		{

		result = KErrGeneral;

		aLog->Log(_L("Length == FAIL"));

		}

	return result;

	}

// -----------------------------------------------------------------------------

// TestExternalize

// Externalises the object.

// -----------------------------------------------------------------------------

//

LOCAL_C TInt TestExternalizeL( CStifLogger* aLog, CSmsBuffer& aBuffer)

	{

	aLog->Log(_L("---------------------------------------------"));

	aLog->Log(_L("Calling ExternalizeL()"));

	RFs session;

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

	TBufC<64> storename = _L("C:\\SMSGSMUtilities_CSmsBuffer");

	RFileWriteStream write;

	write.Create(session, storename, EFileWrite);