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

// Telephony Fax Test main test code.

// 

//

/**

 @file

 @internalComponent

*/

#include "faxdefn.h"

#include "fax_reversebytes.h"

#include "FAXSET.H"

#include "CFAX32.H"

#include "etel.h"

#include "etelmm.h"

#include "faxhuff.h"

#include "TE_FaxBase.h"

#include "TE_FaxTest.h"

//

// Constants...

//

_LIT(KTEFaxTestStoreFileName, "C:\\TestStore.Fax");

_LIT(KTEFaxTestEncodeFileName, "C:\\TestEncode.Fax");

_LIT(KTEFaxTestHeaderFileName, "C:\\TestHeader.Fax");

_LIT(KTEFaxTSYName, "MM");

_LIT(KTEFaxPhoneName, "GsmPhone1");

_LIT(KTEFaxLineName, "Fax");

/**

 *  Each test step initialises it's own name

 */

CFaxTestFaxDefinition::CFaxTestFaxDefinition()

	{

	//

	// Store the name of this test case.  This is the name that is used by

	// the script file.

	//

	SetTestStepName(_L("TestFaxDefinition"));

	} // CFaxTestFaxDefinition::CFaxTestFaxDefinition

/**

 *  This tests the definition of a fax it's variables types.

 *

 *  @return Test verdict for this test.

 */	

enum TVerdict CFaxTestFaxDefinition::doTestStepL()

	{

#ifdef __EABI__

	//

	// Removed due to RVCT warnings!!!

	//

	INFO_PRINTF1(_L("Note: This test is not fully run on RVCT compiled platforms!"));

#else

	TFaxClass  faxClass = EClassAuto;

	faxClass = EClass1;

	TFaxPhase  faxPhase = ENotYetStarted;

	faxPhase = ECallEstablishment;

	TFaxResolution  faxResolution = EFaxNormal;

	faxResolution = EFaxFine;

	TFaxCompression  faxCompression = EModifiedHuffman;

	faxCompression = EModifiedRead;

	TInt  tmpValue;

	tmpValue = KFaxPixelsPerScanLine;

	tmpValue = KFaxBytesPerScanLine;

	tmpValue = KFaxCmPerScanLine;

	tmpValue = KFaxScanLinesPer10Cm;

	tmpValue = KFaxFineScanLinesPer10Cm;

	tmpValue = KFaxT4MaxDesLength;

	tmpValue = KFaxLinesPerBand;

#endif

	TFaxBufSenderId  faxBufSenderId;

	faxBufSenderId.Copy(_L8("Test"));

    TRawScanLine rawscanline;

	rawscanline.Zero();

	rawscanline.SetMax();

	rawscanline.FillZ();

	return TestStepResult();

	} // CFaxTestFaxDefinition::doTestStepL

/**

 *  Each test step initialises it's own name

 */

CFaxTestFaxStorage::CFaxTestFaxStorage()

	{

	//

	// Store the name of this test case.  This is the name that is used by

	// the script file.

	//

	SetTestStepName(_L("TestFaxStorage"));

	} // CFaxTestFaxStorage::CFaxTestFaxStorage

/**

 *  This tests the definition of a fax it's variables types.

 *

 *  @return Test verdict for this test.

 */	

enum TVerdict CFaxTestFaxStorage::doTestStepL()

	{

	INFO_PRINTF1(_L("Started fax store tests"));

    iWriteFaxFile = CWriteFaxFile::NewL();

	CleanupStack::PushL(iWriteFaxFile);

	iReadFaxFile = CReadFaxFile::NewL();

	CleanupStack::PushL(iReadFaxFile);

	iSenderId.Copy(_L("sender's number"));

	TBuf8<216>  scanlineBlack, scanlineWhite, scanlineAlt, scanlineCount;

	TInt  index;

	scanlineBlack.SetLength(216);

	scanlineBlack.Fill(TChar(0));

	scanlineWhite.SetLength(216);

	scanlineWhite.Fill(TChar(255));

	scanlineAlt.SetLength(216);

	scanlineAlt.Fill(TChar(255));

	for (index = 0;  index < 216; index += 2)

		{

		scanlineAlt[index] = 0;

		}

	scanlineCount.SetLength(216);

	for (index = 0;  index < 216;  index++)

		{

		scanlineCount[index] = TUint8(index);

		}

	TInt  numberLines, startnol(124), endnol(132);

	//

	// test 1

	//

	INFO_PRINTF3(_L("Test 1 - %d to %d repeated lines"), startnol, endnol);

	INFO_PRINTF1(_L("All black - Resolution Fine"));

	for (numberLines=startnol; numberLines<=endnol; numberLines++)

		{

		Test1L(numberLines, scanlineBlack, EFaxFine);

		}

	INFO_PRINTF1(_L("All white - Resolution Fine"));

	for (numberLines=startnol; numberLines<=endnol; numberLines++)

		{

		Test1L(numberLines, scanlineWhite, EFaxFine);

		}

	INFO_PRINTF1(_L("Black & White - Resolution Fine"));

	for (numberLines=startnol; numberLines<=endnol; numberLines++)

		{

		Test1L(numberLines, scanlineAlt, EFaxFine);

		}

	INFO_PRINTF1(_L("Counting - Resolution Fine"));

	for (numberLines=startnol; numberLines<=endnol; numberLines++)

		{

		Test1L(numberLines, scanlineCount, EFaxFine);

		}

	INFO_PRINTF1(_L("Black & White - Resolution Normal"));

	for (numberLines=startnol; numberLines<=endnol; numberLines++)

		{

		Test1L(numberLines, scanlineAlt, EFaxNormal);

		}

	INFO_PRINTF1(_L("Counting - Resolution Normal"));

	for (numberLines=startnol; numberLines<=endnol; numberLines++)

		{

		Test1L(numberLines, scanlineCount, EFaxNormal);

		}

	//

	// test 2

	//

	INFO_PRINTF3(_L("Test 2 - %d to %d alternated lines"), startnol, endnol);

	INFO_PRINTF1(_L("White and Black & White - Resolution Fine"));

	for (numberLines = startnol;  numberLines <= endnol;  numberLines++)

		{

		Test2L(numberLines, scanlineWhite, scanlineAlt, EFaxFine);

		}

	INFO_PRINTF1(_L("Black and Black & White - Resolution Fine"));

	for (numberLines = startnol;  numberLines <= endnol;  numberLines++)

		{

		Test2L(numberLines, scanlineBlack, scanlineAlt, EFaxFine);

		}

	INFO_PRINTF1(_L("Counting and Black & White - Resolution Fine"));

	for (numberLines = startnol;  numberLines <= endnol;  numberLines++)

		{

		Test2L(numberLines, scanlineCount, scanlineAlt, EFaxFine);

		}

	//

	// test 3

	//

	TInt  numberPages, maxNumberPages=5;

	INFO_PRINTF2(_L("Test 3 - 2 to %d pages"), maxNumberPages);

	for (numberPages = 2;  numberPages <= maxNumberPages;  numberPages++) 

		{

		INFO_PRINTF2(_L("%d pages"),numberPages);

		for (numberLines = startnol;  numberLines <= endnol;  numberLines++)

			{

			Test3L(numberLines, numberPages);

			}

		}

	//

	// test 4

	//

	INFO_PRINTF1(_L("Test 4 - seeking lines"));

	for (numberLines = startnol;  numberLines <= startnol;  numberLines++)

		{

		Test4L(numberLines);

		}

	//

	// test 5

	//

	TFaxBufSenderId  sd;

	INFO_PRINTF1(_L("Test 5 - writing and reading page info"));

	sd.Copy(_L8("+34345 4354"));

	Test5L(EFaxNormal,sd,EModifiedHuffman,TInt(2434));

	sd.Copy(_L8("+34345 4354"));

	Test5L(EFaxFine,sd,EModifiedHuffman,TInt(0));

	sd.Copy(_L8(""));

	Test5L(EFaxNormal,sd,EModifiedHuffman,TInt(1));

	sd.Copy(_L8(" + 4545 9"));

	Test5L(EFaxFine,sd,EModifiedHuffman,TInt(-1));

	//

	// Done!

	//

	CleanupStack::PopAndDestroy(iReadFaxFile);

	CleanupStack::PopAndDestroy(iWriteFaxFile);

	return TestStepResult();

	} // CFaxTestFaxStorage::doTestStepL

void CFaxTestFaxStorage::Test1L(TInt aNumberLines, TBuf8<216>& aScanLineWrite,

								TFaxResolution aRes)

	{

	TInt  row;

	TBuf8<216>  scanlineRead;

	iWriteFaxFile->OpenL(KTEFaxTestStoreFileName, 64);

	for (row = 0;  row < aNumberLines;  row++)

		{

		iWriteFaxFile->iWriteFaxPages->AddScanLineL(aScanLineWrite);

		}

	iWriteFaxFile->iWriteFaxPages->EndPageL(aRes, iSenderId);

	iWriteFaxFile->CommitL();

	iWriteFaxFile->Close();

	iReadFaxFile->OpenL(KTEFaxTestStoreFileName);

	for (row = 0;  row < aNumberLines;  row++)

		{

		iReadFaxFile->iReadFaxPages->GetScanLineL(scanlineRead);

		TESTCHECKSTR(scanlineRead, aScanLineWrite);

		}

	iReadFaxFile->Close();

	} // CFaxTestFaxStorage::Test1L

void CFaxTestFaxStorage::Test2L(TInt aNumberLines, TBuf8<216>& aScanLineWrite1,

								TBuf8<216>&  aScanLineWrite2, TFaxResolution aRes)

	{

	TInt  row;

	TBuf8<216>  scanlineRead;

	iWriteFaxFile->OpenL(KTEFaxTestStoreFileName, 64);

	for (row = 0; row < aNumberLines;  row++)

		{

		// line1

		iWriteFaxFile->iWriteFaxPages->AddScanLineL(aScanLineWrite1);

		row++;

		if (row >= aNumberLines)

			{

			break;

			}

		// line2

		iWriteFaxFile->iWriteFaxPages->AddScanLineL(aScanLineWrite2);

		}

	iWriteFaxFile->iWriteFaxPages->EndPageL(aRes, iSenderId);

	iWriteFaxFile->CommitL();

	iWriteFaxFile->Close();

	iReadFaxFile->OpenL(KTEFaxTestStoreFileName);

	for (row = 0;  row < aNumberLines;  row++)

		{

		// line1

		iReadFaxFile->iReadFaxPages->GetScanLineL(scanlineRead);

		TESTCHECKSTR(scanlineRead, aScanLineWrite1);

		row++;

		if (row >= aNumberLines)

			{

			break;

			}

		// line2

		iReadFaxFile->iReadFaxPages->GetScanLineL(scanlineRead);

		TESTCHECKSTR(scanlineRead, aScanLineWrite2);

		}

	iReadFaxFile->Close();

	} // CFaxTestFaxStorage::Test2L

void CFaxTestFaxStorage::Test3L(TInt aNumberLines, TInt aNumberPages)

	{

	TInt  row;

	TBuf8<216>  scanlineRead, scanlineWrite;

	scanlineWrite.SetLength(216);

	iWriteFaxFile->OpenL(KTEFaxTestStoreFileName, 64);

	TInt page;

	for (page = 0;  page < aNumberPages;  page++)

		{

		scanlineWrite.SetLength(216);

		scanlineWrite.Fill(TChar(255));

		for (TInt t=0; t<216; t+=2)

			{

			scanlineWrite[t] = 0;

			}

		scanlineWrite[0] = TUint8(page);

		for (row = 0;  row < aNumberLines;  row++)

			{

			iWriteFaxFile->iWriteFaxPages->AddScanLineL(scanlineWrite);

			}

		iWriteFaxFile->iWriteFaxPages->EndPageL(EFaxFine, iSenderId);

		iWriteFaxFile->CommitL();

		}

	iWriteFaxFile->Close();

	iReadFaxFile->OpenL(KTEFaxTestStoreFileName);

	for (page = 0;  page < aNumberPages;  page++)

		{

		iReadFaxFile->iReadFaxPages->SetPageL(page);

		for (row = 0;  row < aNumberLines;  row++)

			{

			iReadFaxFile->iReadFaxPages->GetScanLineL(scanlineRead);	

			TESTCHECK(scanlineRead[0], page);

			}

		}

	iReadFaxFile->Close();

	} // CFaxTestFaxStorage::Test3L

void CFaxTestFaxStorage::Test4L(TInt aNumberLines)

	{

	TInt  row;

	TBuf8<216>  scanlineRead, scanlineWrite;

	scanlineWrite.SetLength(216);

	iWriteFaxFile->OpenL(KTEFaxTestStoreFileName, 64);

	for (row = 0;  row < aNumberLines;  row++)

		{

		scanlineWrite[0] = TUint8(row);

		iWriteFaxFile->iWriteFaxPages->AddScanLineL(scanlineWrite);

		}

	iWriteFaxFile->iWriteFaxPages->EndPageL(EFaxFine, iSenderId);

	iWriteFaxFile->CommitL();

	iWriteFaxFile->Close();

	iReadFaxFile->OpenL(KTEFaxTestStoreFileName);

	for (row = 0;  row < aNumberLines;  row++)

		{

		iReadFaxFile->iReadFaxPages->SeekScanLineL(row);

		iReadFaxFile->iReadFaxPages->GetScanLineL(scanlineRead);

		TESTCHECK(scanlineRead[0], row);

		}

	for (row = aNumberLines - 1;  row >= 0;  row--)

		{

		iReadFaxFile->iReadFaxPages->SeekScanLineL(row);

		iReadFaxFile->iReadFaxPages->GetScanLineL(scanlineRead);

		TESTCHECK(scanlineRead[0], row);

		}

	iReadFaxFile->Close();

	} // CFaxTestFaxStorage::Test4L

void CFaxTestFaxStorage::Test5L(TFaxResolution aRes, TFaxBufSenderId& aSenderId,

								TFaxCompression aF1, TInt aF2)

{

	TInt  row;

	TBuf8<216>  scanLineWrite;

	scanLineWrite.SetLength(216);

	iWriteFaxFile->OpenL(KTEFaxTestStoreFileName, 64);

	for (row=0; row<100; row++)

		{

		iWriteFaxFile->iWriteFaxPages->AddScanLineL(scanLineWrite);

		}

	iWriteFaxFile->iWriteFaxPages->EndPageL(aRes, aSenderId, aF1, aF2);

	iWriteFaxFile->CommitL();

	iWriteFaxFile->Close();

	iReadFaxFile->OpenL(KTEFaxTestStoreFileName);

	TFaxPageInfo info = iReadFaxFile->iReadFaxPages->CurrentPageInfo();

	TESTCHECK(info.iNumScanLines, 100);

	TESTCHECK(info.iResolution, aRes);

	TESTCHECKSTR(info.iSenderId, aSenderId);

	TESTCHECK(info.iCompression, aF1);

	TESTCHECK(info.iReservedFlag2, aF2);

	iReadFaxFile->Close();

}

/**

 *  Each test step initialises it's own name

 */

CFaxTestFaxCoding::CFaxTestFaxCoding()

	{

	//

	// Store the name of this test case.  This is the name that is used by

	// the script file.

	//

	SetTestStepName(_L("TestFaxCoding"));

	} // CFaxTestFaxCoding::CFaxTestFaxCoding

/**

 *  This tests the fax coding.

 *

 *  @return Test verdict for this test.

 */	

enum TVerdict CFaxTestFaxCoding::doTestStepL()

	{

	TInt  result, pos;

	TInt  blackrun;

	TBool  flag(EFalse);

	RFile  enFile;

	RFs  fs;

	TRawScanLine  rawScanLine;

	TBuf8<KFaxT4MaxDesLength>  encodedScanLine;

	TBuf8<50>  leftOvers;

	TRawScanLine  decodedScanLine;

	TTime  then;

	TTime  now;

	TInt64  timetaken;

	CFaxT4* faxT4 = CFaxT4::NewL();

	CleanupStack::PushL(faxT4);

	result = fs.Connect();

	CleanupClosePushL(fs);

	TESTCHECKL(result, KErrNone);

	result = enFile.Replace(fs, KTEFaxTestEncodeFileName, EFileShareAny);

	CleanupClosePushL(enFile);

	TESTCHECKL(result, KErrNone);

	INFO_PRINTF1(_L("Testing 1D coding methods"));

	faxT4->PageInitialize(EFaxFine, EModifiedHuffman);

	rawScanLine.Fill(KFaxWhite, KFaxBytesPerScanLine);

	for (blackrun = 0;  blackrun <= 1728;  blackrun++)

		{

		Mem::Fill(&rawScanLine[0], blackrun/8, KFaxBlack);

		if (blackrun%8)

			{

			rawScanLine[(blackrun/8)] = (TUint8)(KFaxWhite << blackrun%8);

			}

		faxT4->EncodeScanLine(rawScanLine, encodedScanLine);

		encodedScanLine.Append(0);

		encodedScanLine.Append(1);

		enFile.Write(encodedScanLine);

		}

	enFile.Flush();

	CleanupStack::PopAndDestroy(&enFile);