1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Telephony Fax Test main test code.

    15 // 

    16 //

    17 

    18 /**

    19  @file

    20  @internalComponent

    21 */

    22 

    23 #include "faxdefn.h"

    24 #include "fax_reversebytes.h"

    25 #include "FAXSET.H"

    26 #include "CFAX32.H"

    27 #include "etel.h"

    28 #include "etelmm.h"

    29 #include "faxhuff.h"

    30 

    31 #include "TE_FaxBase.h"

    32 #include "TE_FaxTest.h"

    33 

    34 

    35 //

    36 // Constants...

    37 //

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

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

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

    41 _LIT(KTEFaxTSYName, "MM");

    42 _LIT(KTEFaxPhoneName, "GsmPhone1");

    43 _LIT(KTEFaxLineName, "Fax");

    44 

    45 

    46 /**

    47  *  Each test step initialises it's own name

    48  */

    49 CFaxTestFaxDefinition::CFaxTestFaxDefinition()

    50 	{

    51 	//

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

    53 	// the script file.

    54 	//

    55 	SetTestStepName(_L("TestFaxDefinition"));

    56 	} // CFaxTestFaxDefinition::CFaxTestFaxDefinition

    57 

    58 

    59 /**

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

    61  *

    62  *  @return Test verdict for this test.

    63  */	

    64 enum TVerdict CFaxTestFaxDefinition::doTestStepL()

    65 	{

    66 #ifdef __EABI__

    67 	//

    68 	// Removed due to RVCT warnings!!!

    69 	//

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

    71 #else

    72 	TFaxClass  faxClass = EClassAuto;

    73 	faxClass = EClass1;

    74 

    75 	TFaxPhase  faxPhase = ENotYetStarted;

    76 	faxPhase = ECallEstablishment;

    77 

    78 	TFaxResolution  faxResolution = EFaxNormal;

    79 	faxResolution = EFaxFine;

    80 

    81 	TFaxCompression  faxCompression = EModifiedHuffman;

    82 	faxCompression = EModifiedRead;

    83 

    84 	TInt  tmpValue;

    85 	tmpValue = KFaxPixelsPerScanLine;

    86 	tmpValue = KFaxBytesPerScanLine;

    87 	tmpValue = KFaxCmPerScanLine;

    88 	tmpValue = KFaxScanLinesPer10Cm;

    89 	tmpValue = KFaxFineScanLinesPer10Cm;

    90 	tmpValue = KFaxT4MaxDesLength;

    91 	tmpValue = KFaxLinesPerBand;

    92 #endif

    93 

    94 	TFaxBufSenderId  faxBufSenderId;

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

    96 

    97     TRawScanLine rawscanline;

    98 

    99 	rawscanline.Zero();

   100 	rawscanline.SetMax();

   101 	rawscanline.FillZ();

   102 	

   103 	return TestStepResult();

   104 	} // CFaxTestFaxDefinition::doTestStepL

   105 

   106 

   107 /**

   108  *  Each test step initialises it's own name

   109  */

   110 CFaxTestFaxStorage::CFaxTestFaxStorage()

   111 	{

   112 	//

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

   114 	// the script file.

   115 	//

   116 	SetTestStepName(_L("TestFaxStorage"));

   117 	} // CFaxTestFaxStorage::CFaxTestFaxStorage

   118 

   119 

   120 /**

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

   122  *

   123  *  @return Test verdict for this test.

   124  */	

   125 enum TVerdict CFaxTestFaxStorage::doTestStepL()

   126 	{

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

   128 

   129     iWriteFaxFile = CWriteFaxFile::NewL();

   130 	CleanupStack::PushL(iWriteFaxFile);

   131 	iReadFaxFile = CReadFaxFile::NewL();

   132 	CleanupStack::PushL(iReadFaxFile);

   133 

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

   135 

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

   137 	TInt  index;

   138 

   139 	scanlineBlack.SetLength(216);

   140 	scanlineBlack.Fill(TChar(0));

   141 	scanlineWhite.SetLength(216);

   142 	scanlineWhite.Fill(TChar(255));

   143 	scanlineAlt.SetLength(216);

   144 	scanlineAlt.Fill(TChar(255));

   145 	

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

   147 		{

   148 		scanlineAlt[index] = 0;

   149 		}

   150 	scanlineCount.SetLength(216);

   151 

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

   153 		{

   154 		scanlineCount[index] = TUint8(index);

   155 		}

   156 

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

   158 

   159 	//

   160 	// test 1

   161 	//

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

   163 

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

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

   166 		{

   167 		Test1L(numberLines, scanlineBlack, EFaxFine);

   168 		}

   169 

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

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

   172 		{

   173 		Test1L(numberLines, scanlineWhite, EFaxFine);

   174 		}

   175 

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

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

   178 		{

   179 		Test1L(numberLines, scanlineAlt, EFaxFine);

   180 		}

   181 

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

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

   184 		{

   185 		Test1L(numberLines, scanlineCount, EFaxFine);

   186 		}

   187 

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

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

   190 		{

   191 		Test1L(numberLines, scanlineAlt, EFaxNormal);

   192 		}

   193 

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

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

   196 		{

   197 		Test1L(numberLines, scanlineCount, EFaxNormal);

   198 		}

   199 

   200 	//

   201 	// test 2

   202 	//

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

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

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

   206 		{

   207 		Test2L(numberLines, scanlineWhite, scanlineAlt, EFaxFine);

   208 		}

   209 

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

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

   212 		{

   213 		Test2L(numberLines, scanlineBlack, scanlineAlt, EFaxFine);

   214 		}

   215 

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

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

   218 		{

   219 		Test2L(numberLines, scanlineCount, scanlineAlt, EFaxFine);

   220 		}

   221 

   222 	//

   223 	// test 3

   224 	//

   225 	TInt  numberPages, maxNumberPages=5;

   226 

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

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

   229 		{

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

   231 

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

   233 			{

   234 			Test3L(numberLines, numberPages);

   235 			}

   236 		}

   237 

   238 	//

   239 	// test 4

   240 	//

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

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

   243 		{

   244 		Test4L(numberLines);

   245 		}

   246 

   247 	//

   248 	// test 5

   249 	//

   250 	TFaxBufSenderId  sd;

   251 

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

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

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

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

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

   257 	sd.Copy(_L8(""));

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

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

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

   261 

   262 	//

   263 	// Done!

   264 	//

   265 	CleanupStack::PopAndDestroy(iReadFaxFile);

   266 	CleanupStack::PopAndDestroy(iWriteFaxFile);

   267 

   268 	return TestStepResult();

   269 	} // CFaxTestFaxStorage::doTestStepL

   270 

   271 

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

   273 								TFaxResolution aRes)

   274 	{

   275 	TInt  row;

   276 	TBuf8<216>  scanlineRead;

   277 

   278 	iWriteFaxFile->OpenL(KTEFaxTestStoreFileName, 64);

   279 	

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

   281 		{

   282 		iWriteFaxFile->iWriteFaxPages->AddScanLineL(aScanLineWrite);

   283 		}

   284 

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

   286 	iWriteFaxFile->CommitL();

   287 	iWriteFaxFile->Close();

   288 

   289 	iReadFaxFile->OpenL(KTEFaxTestStoreFileName);

   290 

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

   292 		{

   293 		iReadFaxFile->iReadFaxPages->GetScanLineL(scanlineRead);

   294 		TESTCHECKSTR(scanlineRead, aScanLineWrite);

   295 		}

   296 	iReadFaxFile->Close();

   297 	} // CFaxTestFaxStorage::Test1L

   298 

   299 

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

   301 								TBuf8<216>&  aScanLineWrite2, TFaxResolution aRes)

   302 	{

   303 	TInt  row;

   304 	TBuf8<216>  scanlineRead;

   305 

   306 	iWriteFaxFile->OpenL(KTEFaxTestStoreFileName, 64);

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

   308 		{

   309 		// line1

   310 		iWriteFaxFile->iWriteFaxPages->AddScanLineL(aScanLineWrite1);

   311 		row++;

   312 		if (row >= aNumberLines)

   313 			{

   314 			break;

   315 			}

   316 

   317 		// line2

   318 		iWriteFaxFile->iWriteFaxPages->AddScanLineL(aScanLineWrite2);

   319 		}

   320 

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

   322 	iWriteFaxFile->CommitL();

   323 	iWriteFaxFile->Close();

   324 

   325 	iReadFaxFile->OpenL(KTEFaxTestStoreFileName);

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

   327 		{

   328 		// line1

   329 		iReadFaxFile->iReadFaxPages->GetScanLineL(scanlineRead);

   330 		TESTCHECKSTR(scanlineRead, aScanLineWrite1);

   331 		row++;

   332 		if (row >= aNumberLines)

   333 			{

   334 			break;

   335 			}

   336 

   337 		// line2

   338 		iReadFaxFile->iReadFaxPages->GetScanLineL(scanlineRead);

   339 		TESTCHECKSTR(scanlineRead, aScanLineWrite2);

   340 		}

   341 	iReadFaxFile->Close();

   342 	} // CFaxTestFaxStorage::Test2L

   343 

   344 

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

   346 	{

   347 	TInt  row;

   348 	TBuf8<216>  scanlineRead, scanlineWrite;

   349 

   350 	scanlineWrite.SetLength(216);

   351 

   352 	iWriteFaxFile->OpenL(KTEFaxTestStoreFileName, 64);

   353 	TInt page;

   354 	

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

   356 		{

   357 		scanlineWrite.SetLength(216);

   358 		scanlineWrite.Fill(TChar(255));

   359 		

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

   361 			{

   362 			scanlineWrite[t] = 0;

   363 			}

   364 		

   365 		scanlineWrite[0] = TUint8(page);

   366 		

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

   368 			{

   369 			iWriteFaxFile->iWriteFaxPages->AddScanLineL(scanlineWrite);

   370 			}

   371 

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

   373 		iWriteFaxFile->CommitL();

   374 		}

   375 	iWriteFaxFile->Close();

   376 

   377 	iReadFaxFile->OpenL(KTEFaxTestStoreFileName);

   378 

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

   380 		{

   381 		iReadFaxFile->iReadFaxPages->SetPageL(page);

   382 

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

   384 			{

   385 			iReadFaxFile->iReadFaxPages->GetScanLineL(scanlineRead);	

   386 			TESTCHECK(scanlineRead[0], page);

   387 			}

   388 		}

   389 	iReadFaxFile->Close();

   390 	} // CFaxTestFaxStorage::Test3L

   391 

   392 

   393 void CFaxTestFaxStorage::Test4L(TInt aNumberLines)

   394 	{

   395 	TInt  row;

   396 	TBuf8<216>  scanlineRead, scanlineWrite;

   397 

   398 	scanlineWrite.SetLength(216);

   399 

   400 	iWriteFaxFile->OpenL(KTEFaxTestStoreFileName, 64);

   401 

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

   403 		{

   404 		scanlineWrite[0] = TUint8(row);

   405 

   406 		iWriteFaxFile->iWriteFaxPages->AddScanLineL(scanlineWrite);

   407 		}

   408 

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

   410 	iWriteFaxFile->CommitL();

   411 	iWriteFaxFile->Close();

   412 

   413 	iReadFaxFile->OpenL(KTEFaxTestStoreFileName);

   414 

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

   416 		{

   417 		iReadFaxFile->iReadFaxPages->SeekScanLineL(row);

   418 		iReadFaxFile->iReadFaxPages->GetScanLineL(scanlineRead);

   419 		TESTCHECK(scanlineRead[0], row);

   420 		}

   421 

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

   423 		{

   424 		iReadFaxFile->iReadFaxPages->SeekScanLineL(row);

   425 		iReadFaxFile->iReadFaxPages->GetScanLineL(scanlineRead);

   426 		TESTCHECK(scanlineRead[0], row);

   427 		}

   428 

   429 	iReadFaxFile->Close();

   430 	} // CFaxTestFaxStorage::Test4L

   431 

   432 

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

   434 								TFaxCompression aF1, TInt aF2)

   435 {

   436 	TInt  row;

   437 	TBuf8<216>  scanLineWrite;

   438 

   439 	scanLineWrite.SetLength(216);

   440 

   441 	iWriteFaxFile->OpenL(KTEFaxTestStoreFileName, 64);

   442 

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

   444 		{

   445 		iWriteFaxFile->iWriteFaxPages->AddScanLineL(scanLineWrite);

   446 		}

   447 

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

   449 	iWriteFaxFile->CommitL();

   450 	iWriteFaxFile->Close();

   451 

   452 	iReadFaxFile->OpenL(KTEFaxTestStoreFileName);

   453 

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

   455 

   456 	TESTCHECK(info.iNumScanLines, 100);

   457 	TESTCHECK(info.iResolution, aRes);

   458 	TESTCHECKSTR(info.iSenderId, aSenderId);

   459 	TESTCHECK(info.iCompression, aF1);

   460 	TESTCHECK(info.iReservedFlag2, aF2);

   461 

   462 	iReadFaxFile->Close();

   463 }

   464 

   465 

   466 /**

   467  *  Each test step initialises it's own name

   468  */

   469 CFaxTestFaxCoding::CFaxTestFaxCoding()

   470 	{

   471 	//

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

   473 	// the script file.

   474 	//

   475 	SetTestStepName(_L("TestFaxCoding"));

   476 	} // CFaxTestFaxCoding::CFaxTestFaxCoding

   477 

   478 

   479 /**

   480  *  This tests the fax coding.

   481  *

   482  *  @return Test verdict for this test.

   483  */	

   484 enum TVerdict CFaxTestFaxCoding::doTestStepL()

   485 	{

   486 	TInt  result, pos;

   487 	TInt  blackrun;

   488 	TBool  flag(EFalse);

   489 	RFile  enFile;

   490 	RFs  fs;

   491 	TRawScanLine  rawScanLine;

   492 	TBuf8<KFaxT4MaxDesLength>  encodedScanLine;

   493 	TBuf8<50>  leftOvers;

   494 	TRawScanLine  decodedScanLine;

   495 	TTime  then;

   496 	TTime  now;

   497 	TInt64  timetaken;

   498 

   499 	CFaxT4* faxT4 = CFaxT4::NewL();

   500 	CleanupStack::PushL(faxT4);

   501 

   502 	result = fs.Connect();

   503 	CleanupClosePushL(fs);

   504 	TESTCHECKL(result, KErrNone);

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

   506 	CleanupClosePushL(enFile);

   507 	TESTCHECKL(result, KErrNone);

   508 

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

   510 

   511 	faxT4->PageInitialize(EFaxFine, EModifiedHuffman);

   512 	rawScanLine.Fill(KFaxWhite, KFaxBytesPerScanLine);

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

   514 		{

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

   516 		if (blackrun%8)

   517 			{

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

   519 			}

   520 		faxT4->EncodeScanLine(rawScanLine, encodedScanLine);

   521 		encodedScanLine.Append(0);

   522 		encodedScanLine.Append(1);

   523 		enFile.Write(encodedScanLine);

   524 		}

   525 	

   526 	enFile.Flush();

   527 	CleanupStack::PopAndDestroy(&enFile);

   528 

   529 	result = enFile.Open(fs, KTEFaxTestEncodeFileName, EFileShareAny);

   530 	CleanupClosePushL(enFile);

   531 	TESTCHECKL(result, KErrNone);

   532 

   533 	// now encoded.fax contains the encoded RawScanLines from the jerry.fax file

   534 	// and now we are going to decode them again

   535 

   536 	encodedScanLine.Zero();

   537 

   538 	then.UniversalTime();

   539     faxT4->PageInitialize(EFaxFine,EModifiedHuffman);

   540 	rawScanLine.Fill(KFaxWhite, KFaxBytesPerScanLine);

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

   542 		{

   543 		pos = FindEndOfLine(encodedScanLine);

   544 		if (pos == KErrNotFound)

   545 			{

   546 			flag = ETrue;

   547 			if (encodedScanLine.Length() != 0)

   548 				{

   549 				leftOvers.Copy(encodedScanLine);

   550 				enFile.Read(encodedScanLine, (encodedScanLine.MaxLength()-leftOvers.Length()));

   551 

   552 				if (FindEndOfLine(encodedScanLine) == KErrNotFound)

   553 				{

   554 					User::Leave(KErrNotFound);

   555 				}

   556 			

   557 				encodedScanLine.Insert(0, leftOvers);

   558 				leftOvers.Zero();

   559 				pos = FindEndOfLine(encodedScanLine);

   560 				flag = EFalse;

   561 				}

   562 			

   563 			if (flag)

   564 				{

   565 				enFile.Read(encodedScanLine);

   566 				pos = FindEndOfLine(encodedScanLine);

   567 				}

   568 			}

   569 

   570 		result = faxT4->DecodeScanLine(decodedScanLine, encodedScanLine.Left(pos));

   571 		TESTCHECKL(result, KErrNone);

   572 		

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

   574 		if (blackrun%8)

   575 			{

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

   577 			}

   578 

   579 		TEST(!rawScanLine.Compare(decodedScanLine));

   580 		encodedScanLine.Delete(0,pos+2);	//2 is the length of the delimiter character.

   581 		}

   582 	now.UniversalTime();

   583 	timetaken = now.MicroSecondsFrom(then).Int64();

   584 	INFO_PRINTF2(_L("%dms to 1D encode all possible run lengths"), I64LOW(timetaken)/1000);

   585 

   586 	enFile.Flush();

   587 	CleanupStack::PopAndDestroy(&enFile);

   588 

   589 	//

   590 	// Again, for this test, we'll instantiate our own CFaxT4 object and generate

   591 	// the fax file using the raw functions  - this is purely done for testing

   592 	// and in real life we'd do a 2D fax via the StartPage() function 

   593 	// as used in test8L

   594 	//

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

   596 	CleanupClosePushL(enFile);

   597 	TESTCHECKL(result, KErrNone);

   598 

   599 	INFO_PRINTF1(_L("Test 2D coding methods"));

   600 

   601 	//writeFaxFile->OpenL(_L("c:\\test.fax"),64);

   602 	

   603 	faxT4->PageInitialize(EFaxFine, EModifiedRead);

   604 	rawScanLine.Fill(KFaxBlack, KFaxBytesPerScanLine);      // prepare a black reference line

   605 	faxT4->EncodeScanLine(rawScanLine, encodedScanLine);

   606 	

   607 	//writeFaxFile->iWriteFaxPages->AddEncodedScanLineL(encodedScanLine);

   608 	encodedScanLine.Append(0);

   609 	encodedScanLine.Append(1);

   610 	enFile.Write(encodedScanLine);

   611 

   612 	rawScanLine[0] = KFaxWhite ;                             // start with a white run

   613 	rawScanLine[KFaxBytesPerScanLine-1] = KFaxWhite ;        // end with a white run

   614 	rawScanLine[(KFaxBytesPerScanLine/2)-1] = KFaxWhite ;    // with a white run halfway through

   615 	rawScanLine[(KFaxBytesPerScanLine/2)-10] = KFaxWhite ;    // and a white run 10 before the end

   616 	faxT4->EncodeScanLine(rawScanLine, encodedScanLine);      // horizontal mode encoding

   617 

   618 

   619 	//writeFaxFile->iWriteFaxPages->AddEncodedScanLineL(encodedScanLine);

   620 	encodedScanLine.Append(0);

   621 	encodedScanLine.Append(1);

   622 	enFile.Write(encodedScanLine);

   623 

   624 	rawScanLine[0] = KFaxWhite;                             // first run identical for v0

   625 	rawScanLine[(KFaxBytesPerScanLine/2)-1] = 0x1c ;         // 00011100 test v+3 v-2 

   626 	rawScanLine[(KFaxBytesPerScanLine/2)-10] = 0x3e ;        // 00111110 test v+2 v-1 

   627 	rawScanLine[KFaxBytesPerScanLine-1] = 0x78 ;             // 01111000 test v+1 v-3

   628 	faxT4->EncodeScanLine(rawScanLine, encodedScanLine);      // vertical mode encoding

   629 	encodedScanLine.Append(0);

   630 	encodedScanLine.Append(1);

   631 	enFile.Write(encodedScanLine);

   632 	

   633 	

   634 	//writeFaxFile->iWriteFaxPages->AddEncodedScanLineL(encodedScanLine);

   635 	rawScanLine[0] = KFaxBlack ;                             // for pass mode

   636 	faxT4->EncodeScanLine(rawScanLine, encodedScanLine);      // pass mode encoding

   637 	encodedScanLine.Append(0);

   638 	encodedScanLine.Append(1);

   639 	enFile.Write(encodedScanLine);

   640 	//writeFaxFile->iWriteFaxPages->AddEncodedScanLineL(encodedScanLine);

   641 

   642 	// same again in opposite colours

   643 

   644 	faxT4->PageInitialize(EFaxFine, EModifiedRead);

   645 	rawScanLine.Fill(KFaxWhite, KFaxBytesPerScanLine);      // prepare a white reference line

   646 	faxT4->EncodeScanLine(rawScanLine, encodedScanLine);

   647 	encodedScanLine.Append(0);

   648 	encodedScanLine.Append(1);

   649 	enFile.Write(encodedScanLine);

   650 	//writeFaxFile->iWriteFaxPages->AddEncodedScanLineL(encodedScanLine);

   651 	

   652 	rawScanLine[0] = KFaxBlack ;                             // start with a black run

   653 	rawScanLine[KFaxBytesPerScanLine-1] = KFaxBlack ;        // end with a black run

   654 	rawScanLine[(KFaxBytesPerScanLine/2)-1] = KFaxBlack ;    // with a black run halfway through

   655 	rawScanLine[(KFaxBytesPerScanLine/2)-10] = KFaxBlack ;    // and a blacke run 10 before the end

   656 	faxT4->EncodeScanLine(rawScanLine, encodedScanLine);      // horizontal mode encoding

   657 	encodedScanLine.Append(0);

   658 	encodedScanLine.Append(1);

   659 	enFile.Write(encodedScanLine);

   660 

   661 	//writeFaxFile->iWriteFaxPages->AddEncodedScanLineL(encodedScanLine);

   662 	

   663 	rawScanLine[0] = KFaxBlack ;                             // first run identical for v0

   664 	rawScanLine[(KFaxBytesPerScanLine/2)-1] = 0xe3 ;         // 11100011 test v+3 v-2 

   665 	rawScanLine[(KFaxBytesPerScanLine/2)-10] = 0xc1 ;        // 11000001 test v+2 v-1 

   666 	rawScanLine[KFaxBytesPerScanLine-1] = 0x87 ;             // 10000111 test v+1 v-3

   667 	faxT4->EncodeScanLine(rawScanLine, encodedScanLine);      // vertical mode encoding

   668 	encodedScanLine.Append(0);

   669 	encodedScanLine.Append(1);

   670 	enFile.Write(encodedScanLine);

   671 	//writeFaxFile->iWriteFaxPages->AddEncodedScanLineL(encodedScanLine);

   672 	

   673 	rawScanLine[0] = KFaxWhite ;                             // for pass mode

   674 	faxT4->EncodeScanLine(rawScanLine, encodedScanLine);      // pass mode encoding

   675 	//writeFaxFile->iWriteFaxPages->AddEncodedScanLineL(encodedScanLine);

   676 	encodedScanLine.Append(0);

   677 	encodedScanLine.Append(1);

   678 	enFile.Write(encodedScanLine);

   679 

   680 	then.UniversalTime();

   681 	faxT4->PageInitialize (EFaxFine, EModifiedRead);         // now start again

   682 	rawScanLine.Fill (KFaxWhite, KFaxBytesPerScanLine);

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

   684 		{

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

   686 		if (blackrun%8)

   687 			{

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

   689 			}

   690 		faxT4->EncodeScanLine(rawScanLine, encodedScanLine);

   691 		//writeFaxFile->iWriteFaxPages->AddEncodedScanLineL(encodedScanLine);

   692 		encodedScanLine.Append(0);

   693 		encodedScanLine.Append(1);

   694 		enFile.Write(encodedScanLine);

   695 		}

   696 	now.UniversalTime();

   697 	timetaken = now.MicroSecondsFrom (then).Int64 ();

   698 	INFO_PRINTF2(_L("%dms to 2D encode all possible run lengths"), I64LOW(timetaken)/1000);

   699 

   700 	enFile.Flush();

   701 	CleanupStack::PopAndDestroy(&enFile);

   702 

   703 	/*

   704 	writeFaxFile->iWriteFaxPages->EndPageL(EFaxFine,senderId, EModifiedRead);

   705 	writeFaxFile->CommitL();

   706 	writeFaxFile->Close();

   707 	*/

   708 

   709 	//readFaxFile->OpenL(_L("c:\\test.fax"));

   710 	//readFaxFile->iReadFaxPages->SetPageL(0);

   711 	//TFaxPageInfo info = readFaxFile->iReadFaxPages->CurrentPageInfo();

   712 

   713 	INFO_PRINTF1(_L("Test 2D decoding methods"));

   714 

   715 	result = enFile.Open(fs, KTEFaxTestEncodeFileName, EFileShareAny);

   716 	CleanupClosePushL(enFile);

   717 	TESTCHECKL(result, KErrNone);

   718 

   719 	rawScanLine.Fill(KFaxBlack, KFaxBytesPerScanLine);      // prepare a black line as the reference line

   720 	//readFaxFile->iReadFaxPages->GetEncodedScanLineL(encodedScanLine);

   721 

   722 	enFile.Read(encodedScanLine);

   723 	pos = FindEndOfLine(encodedScanLine);

   724 

   725 	result = faxT4->DecodeScanLine(decodedScanLine, encodedScanLine.Left(pos));

   726 	//err = faxT4->DecodeScanLine(decodedScanLine, encodedScanLine);

   727 	TESTCHECKL(result, KErrNone);

   728 	result = rawScanLine.Compare(decodedScanLine);

   729 	TESTCHECKL(result, KErrNone);

   730 	encodedScanLine.Delete(0,pos+2);

   731 

   732 	rawScanLine[0] = KFaxWhite ;

   733 	rawScanLine[KFaxBytesPerScanLine-1] = KFaxWhite ;

   734 	rawScanLine[(KFaxBytesPerScanLine/2)-1] = KFaxWhite ;    // test horizontal mode codec

   735 	rawScanLine[(KFaxBytesPerScanLine/2)-10] = KFaxWhite ;   // and a white run 10 before the end

   736 	

   737 	//enFile.Read(encodedScanLine);

   738 	pos = FindEndOfLine(encodedScanLine);

   739 

   740 	//err = faxT4->DecodeScanLine(decodedScanLine,encodedScanLine.Left(pos));

   741 	//readFaxFile->iReadFaxPages->GetEncodedScanLineL(encodedScanLine);

   742 	

   743 	result = faxT4->DecodeScanLine(decodedScanLine,encodedScanLine.Left(pos));

   744 	TESTCHECKL(result, KErrNone);

   745 	result = rawScanLine.Compare(decodedScanLine);

   746 	TESTCHECKL(result, KErrNone);

   747 	encodedScanLine.Delete(0,pos+2);

   748 

   749 	rawScanLine[(KFaxBytesPerScanLine/2)-1] = 0x1c ;         // test v+3 v-2

   750 	rawScanLine[(KFaxBytesPerScanLine/2)-10] = 0x3e ;        // test v+2 v-1 coded 

   751 	rawScanLine[KFaxBytesPerScanLine-1] = 0x78 ;             // test v+1 v-3 codec

   752 

   753 	//readFaxFile->iReadFaxPages->GetEncodedScanLineL(encodedScanLine);	

   754 	pos=FindEndOfLine(encodedScanLine);

   755 	result = faxT4->DecodeScanLine(decodedScanLine,encodedScanLine.Left(pos));

   756 	TESTCHECKL(result, KErrNone);

   757 	result = rawScanLine.Compare(decodedScanLine);

   758 	TESTCHECKL(result, KErrNone);

   759 	encodedScanLine.Delete(0,pos+2);

   760 	

   761 	rawScanLine[0] = KFaxBlack ;                      // test pass and v0 codec

   762 	//readFaxFile->iReadFaxPages->GetEncodedScanLineL(encodedScanLine);	

   763 	pos=FindEndOfLine(encodedScanLine);

   764 	result = faxT4->DecodeScanLine(decodedScanLine,encodedScanLine.Left(pos));

   765 	TESTCHECKL(result, KErrNone);

   766 	result = rawScanLine.Compare(decodedScanLine);

   767 	TESTCHECKL(result, KErrNone);

   768 	encodedScanLine.Delete(0,pos+2);

   769 	// same again in opposite colours

   770 

   771 	rawScanLine.Fill (KFaxWhite, KFaxBytesPerScanLine);      // prepare a white line as the reference line

   772 	pos=FindEndOfLine(encodedScanLine);

   773 	//readFaxFile->iReadFaxPages->GetEncodedScanLineL(encodedScanLine);	

   774 	result = faxT4->DecodeScanLine(decodedScanLine,encodedScanLine.Left(pos));

   775 	TESTCHECKL(result, KErrNone);

   776 	rawScanLine.Compare(decodedScanLine);

   777 	TESTCHECKL(result, KErrNone);

   778 	encodedScanLine.Delete(0,pos+2);

   779 

   780 

   781 	rawScanLine[0] = KFaxBlack ;

   782 	rawScanLine[KFaxBytesPerScanLine-1] = KFaxBlack ;

   783 	rawScanLine[(KFaxBytesPerScanLine/2)-1] = KFaxBlack ;    // test horizontal mode codec

   784 	rawScanLine[(KFaxBytesPerScanLine/2)-10] = KFaxBlack ;   // and a black run 10 before the end

   785 	//readFaxFile->iReadFaxPages->GetEncodedScanLineL(encodedScanLine);

   786 	pos=FindEndOfLine(encodedScanLine);

   787 	result = faxT4->DecodeScanLine(decodedScanLine,encodedScanLine.Left(pos));

   788 	TESTCHECKL(result, KErrNone);

   789 	result = rawScanLine.Compare(decodedScanLine);

   790 	TESTCHECKL(result, KErrNone);

   791 	encodedScanLine.Delete(0,pos+2);

   792 	

   793 	rawScanLine[(KFaxBytesPerScanLine/2)-1] = 0xe3 ;         // 11100011 test v+3 v-2 

   794 	rawScanLine[(KFaxBytesPerScanLine/2)-10] = 0xc1 ;        // 11000001 test v+2 v-1 

   795 	rawScanLine[KFaxBytesPerScanLine-1] = 0x87 ;             // 10000111 test v+1 v-3

   796 	//readFaxFile->iReadFaxPages->GetEncodedScanLineL(encodedScanLine);	

   797 

   798 	pos=FindEndOfLine(encodedScanLine);

   799 	result = faxT4->DecodeScanLine(decodedScanLine,encodedScanLine.Left(pos));

   800 	TESTCHECKL(result, KErrNone);

   801 	result = rawScanLine.Compare(decodedScanLine);

   802 	TESTCHECKL(result, KErrNone);

   803 	encodedScanLine.Delete(0,pos+2);

   804 

   805 	rawScanLine[0] = KFaxWhite ;                             // test pass and v0 codec

   806 	//readFaxFile->iReadFaxPages->GetEncodedScanLineL(encodedScanLine);	

   807 	pos=FindEndOfLine(encodedScanLine);

   808 	result = faxT4->DecodeScanLine(decodedScanLine,encodedScanLine.Left(pos));

   809 	TESTCHECKL(result, KErrNone);

   810 	result = rawScanLine.Compare(decodedScanLine);

   811 	TESTCHECKL(result, KErrNone);

   812 	encodedScanLine.Delete(0,pos+2);

   813 	

   814 	// now do all run lengths

   815 

   816 	then.UniversalTime();

   817 	//faxT4->PageInitialize (info.iResolution, info.iCompression);

   818 //	enFile.Close();

   819 

   820 //	err=enFile.Open(fs,_L("c:\\test.fax"),EFileShareAny);

   821 //	if (err!=KErrNone)

   822 //		User::Leave(err);

   823 

   824 //	encodedScanLine.Zero();

   825 	flag = EFalse;

   826 

   827     

   828 	faxT4->PageInitialize(EFaxFine,EModifiedRead);

   829 	rawScanLine.Fill(KFaxWhite, KFaxBytesPerScanLine);

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

   831 		{

   832 		pos = FindEndOfLine(encodedScanLine);

   833 		if (pos == KErrNotFound)

   834 			{

   835 			flag = ETrue;

   836 			if (encodedScanLine.Length() != 0)

   837 				{

   838 				leftOvers.Copy(encodedScanLine);

   839 				enFile.Read(encodedScanLine, (encodedScanLine.MaxLength()-leftOvers.Length()));

   840 				if (FindEndOfLine(encodedScanLine) == KErrNotFound)

   841 					{

   842 					User::Leave(KErrNotFound);

   843 					}

   844 			

   845 				encodedScanLine.Insert(0, leftOvers);

   846 				leftOvers.Zero();

   847 				pos = FindEndOfLine(encodedScanLine);

   848 				flag = EFalse;

   849 				}

   850 			

   851 			if (flag)

   852 				{

   853 				enFile.Read(encodedScanLine);

   854 				pos = FindEndOfLine(encodedScanLine);

   855 				}

   856 			}

   857 

   858 		result = faxT4->DecodeScanLine(decodedScanLine,encodedScanLine.Left(pos));

   859 		TESTCHECKL(result, KErrNone);

   860 		

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

   862 		if (blackrun%8)

   863 			{

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

   865 			}

   866 		result = rawScanLine.Compare(decodedScanLine);

   867 		TESTCHECKL(result, KErrNone);

   868 		encodedScanLine.Delete(0,pos+2);	//2 is the length of the delimiter character.

   869 		}

   870 	enFile.Flush();

   871 

   872 	CleanupStack::PopAndDestroy(&enFile);

   873 	CleanupStack::PopAndDestroy(&fs);

   874 	CleanupStack::PopAndDestroy(faxT4);

   875 

   876 	return TestStepResult();

   877 	} // CFaxTestFaxCoding::doTestStepL

   878 

   879 

   880 TInt CFaxTestFaxCoding::FindEndOfLine(TDes8& aEncodedDes)

   881 	{

   882 	TInt  maxlength;

   883 	TUint  compareWord(0);

   884 

   885 	maxlength = aEncodedDes.Length();

   886 	if (aEncodedDes.Length() == 0)

   887 		{

   888 		return KErrNotFound;

   889 		}

   890 

   891 	TInt  index;

   892 

   893 	for (index = 0;  index <= maxlength - 2;  index++)

   894 		{

   895 		compareWord = aEncodedDes[index];

   896 		if (compareWord == 0)

   897 			{

   898 			compareWord = aEncodedDes[index + 1];

   899 			if (compareWord == 1)

   900 				{

   901 				return index;

   902 				}

   903 			}

   904 		}		

   905 		

   906 	return KErrNotFound;

   907 	}

   908 

   909 	

   910 /**

   911  *  Each test step initialises it's own name

   912  */

   913 CFaxTestFaxHeaderDefinition::CFaxTestFaxHeaderDefinition()

   914 	{

   915 	//

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

   917 	// the script file.

   918 	//

   919 	SetTestStepName(_L("TestFaxHeaderDefinition"));

   920 	} // CFaxTestFaxHeaderDefinition::CFaxTestFaxHeaderDefinition

   921 

   922 

   923 /**

   924  *  This tests the fax header definition...

   925  *

   926  *  @return Test verdict for this test.

   927  */	

   928 enum TVerdict CFaxTestFaxHeaderDefinition::doTestStepL()

   929 	{

   930 	//

   931     // this test is in two halves

   932 	//

   933     // firstly we generate a header file - we don't do this via an Epoc print, but

   934     // directly using one of the test fonts in testfont.h.  However, the functions

   935     // we need are all exercised (writing font information and writing series of

   936     // TRawScanLines.  (Getting epoc printing to generate the correct data is not

   937     // part of this test.)  The test function here takes a pointer to the font

   938     // together with its dimensions as paramters, so that fonts 1 2 and 3 bytes

   939     // wide can be tested out all at te same time.  The fonts are in testfont.h

   940     //

   941     // secondly we use the header file we've just generate to create encoded scan lines

   942     // for a header, which we'll write to TEST.FAX as a fax file.  Naturally, in

   943     // real use, we'd send our encodes scan lines as part of the T.4 image at the start

   944     // of each pages, but generating a fax image (which is just a series of encoded scan

   945     // lines) is just as good a test.  So, we pass a pointer to the fax store as a parameters.

   946     // Again, we run this once for each font we test.

   947 	//

   948 	RFs  fs;

   949 	TInt  result;

   950 	RFile  file;

   951 

   952 	result = fs.Connect();

   953 	CleanupClosePushL(fs);

   954 	TESTCHECKL(result, KErrNone);

   955 	

   956 	result = file.Replace(fs, KTEFaxTestHeaderFileName, EFileShareAny);

   957 	CleanupClosePushL(file);

   958 	TESTCHECKL(result, KErrNone);

   959 

   960 	INFO_PRINTF1(_L("Generating header file using one byte wide font"));

   961     GenerateHeaderFileL(*font8x16, 1, 16);

   962 	INFO_PRINTF1(_L("Writing fax header to TestHeader.Fax using current time and date")) ;

   963     GenerateFaxFileL(file);

   964 

   965 	INFO_PRINTF1(_L("Generating header file using two bytes wide font"));

   966     GenerateHeaderFileL(*font16x16, 2, 16);

   967 	INFO_PRINTF1(_L("Writing fax header to TestHeader.Fax using current time and date"));

   968 	GenerateFaxFileL(file);

   969 

   970 	INFO_PRINTF1(_L("Generating header file using three bytes wide font")) ;

   971     GenerateHeaderFileL(*font24x16, 3, 16);

   972 	INFO_PRINTF1(_L("Writing fax header to TestHeader.Fax using current time and date")) ;

   973 	GenerateFaxFileL(file);

   974 	

   975 	file.Flush();

   976 

   977 	CleanupStack::PopAndDestroy(&file);

   978 	CleanupStack::PopAndDestroy(&fs);

   979 

   980 	return TestStepResult();

   981 	} // CFaxTestFaxHeaderDefinition::doTestStepL

   982 

   983 

   984 void CFaxTestFaxHeaderDefinition::GenerateFaxFileL(RFile& aFile)

   985    {

   986     // use the header to generate a *.FAX file

   987     TFaxHeaderInfo faxHeader;

   988 

   989 	CFaxT4*  faxT4 = CFaxT4::NewL();

   990 	CleanupStack::PushL(faxT4);

   991     CFaxHeaderLines*  testheader = CFaxHeaderLines::NewL();

   992 	CleanupStack::PushL(testheader);

   993 

   994     testheader->ReadFaxHeaderInfoL(faxHeader);

   995 

   996     TRawScanLine  headline;

   997     TRawScanLine  fontline;

   998     TBuf8<KFaxT4MaxDesLength>  encodedHeadLine;

   999 

  1000     TTime  timeOfTransmission;

  1001     TBuf<12>  timeText;

  1002 

  1003 	timeOfTransmission.HomeTime ();

  1004     timeOfTransmission.FormatL(timeText, _L("%F%D%M%Y%H%T"));

  1005 

  1006 	for (TInt index = 0;  index < 12;  index++)

  1007 		{

  1008         timeText[index] -= '0';

  1009 		}

  1010 

  1011     // Forces 2 digit day - 2 digit month - 4 digit year - 2 digit hour - 2 digit minute

  1012 

  1013 	for (TInt scanline = 0;  scanline < faxHeader.iHeaderFontHeightInLines;  scanline++)

  1014 		{

  1015         testheader->ReadRawHeaderLineL(scanline, headline);

  1016         testheader->ReadRawFontLineL(scanline, fontline);

  1017 

  1018         for (TInt fontByte = 0; fontByte < faxHeader.iHeaderFontWidthInBytes; fontByte++)

  1019 			{

  1020 			headline[((faxHeader.iOffsetToDay) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[0] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

  1021             headline[((faxHeader.iOffsetToDay + 1) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[1] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

  1022             headline[((faxHeader.iOffsetToMonth) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[2] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

  1023             headline[((faxHeader.iOffsetToMonth + 1) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[3] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

  1024             headline[((faxHeader.iOffsetToYear) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[4] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

  1025             headline[((faxHeader.iOffsetToYear + 1) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[5] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

  1026             headline[((faxHeader.iOffsetToYear + 2) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[6] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

  1027             headline[((faxHeader.iOffsetToYear + 3) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[7] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

  1028             headline[((faxHeader.iOffsetToHour) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[8] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

  1029             headline[((faxHeader.iOffsetToHour + 1) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[9] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

  1030             headline[((faxHeader.iOffsetToMinute) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[10] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

  1031             headline[((faxHeader.iOffsetToMinute + 1) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(timeText[11] * faxHeader.iHeaderFontWidthInBytes) + fontByte];

  1032 

  1033             // put the page info in as 12/34

  1034 

  1035             headline[((faxHeader.iOffsetToCurrentPage) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(1 * faxHeader.iHeaderFontWidthInBytes) + fontByte];

  1036             headline[((faxHeader.iOffsetToCurrentPage + 1) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(2 * faxHeader.iHeaderFontWidthInBytes) + fontByte];

  1037             headline[((faxHeader.iOffsetToTotalPages) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(3 * faxHeader.iHeaderFontWidthInBytes) + fontByte];

  1038             headline[((faxHeader.iOffsetToTotalPages + 1) * faxHeader.iHeaderFontWidthInBytes) + fontByte] = fontline[(4 * faxHeader.iHeaderFontWidthInBytes) + fontByte];

  1039 			}

  1040 

  1041       faxT4->EncodeScanLine(headline, encodedHeadLine);

  1042 	  aFile.Write(encodedHeadLine);

  1043       }

  1044 

  1045 	CleanupStack::PopAndDestroy(testheader);

  1046 	CleanupStack::PopAndDestroy(faxT4);

  1047 	} // CFaxTestFaxHeaderDefinition::GenerateFaxFileL

  1048 

  1049 

  1050 void CFaxTestFaxHeaderDefinition::GenerateHeaderFileL(const TUint8* aFont,

  1051 													  TInt aWidth, TInt aHeight)

  1052 	{

  1053     TFaxHeaderInfo  faxHeader;

  1054 

  1055     //

  1056 	// declare the font size

  1057 	//

  1058     faxHeader.iHeaderFontWidthInBytes  = aWidth;

  1059     faxHeader.iHeaderFontHeightInLines = aHeight;

  1060 

  1061     //

  1062 	// Work out the number of characters we can get in the scan line, so that we can

  1063     // create a modifiable buffer to hold the header line and fill it with spaces

  1064     //

  1065 	TInt  charactersPerLine = KFaxBytesPerScanLine / faxHeader.iHeaderFontWidthInBytes;

  1066     HBufC8*  textBuff = HBufC8::NewL(charactersPerLine);

  1067 	CleanupStack::PushL(textBuff);

  1068 

  1069     TPtr8  textLine = textBuff->Des();

  1070     textLine.Fill(0x20, charactersPerLine);

  1071 

  1072     //

  1073 	// Work out the margin we leave on each side of the page in characters

  1074     // this is specified as 74 pixels in T.4

  1075 	//

  1076 	TInt  margin = (74 / (8 * faxHeader.iHeaderFontWidthInBytes));

  1077 

  1078 	//

  1079 	// THE FOLLOWING LAYOUT IS PURELY FOR TEST PURPOSES AND SHOULDN'T

  1080     // BE TAKEN TO BE A DEFINITIVE HEADER LAYOUT

  1081 	//

  1082     // assume we have the date and time on the lefthand side as dd/mm/yyyy hh:mm

  1083     // 0000000001111111

  1084     // 1234567890123456

  1085     // fill in the separators

  1086 	textLine.Replace(margin + 3, 1, _L8 ("/"));

  1087     textLine.Replace(margin + 6, 1, _L8 ("/"));

  1088     textLine.Replace(margin + 14, 1, _L8 (":"));

  1089 

  1090     //

  1091 	// set up the offsets to the data

  1092 	//

  1093 	faxHeader.iOffsetToDay = margin + 1;

  1094     faxHeader.iOffsetToMonth = margin + 4;

  1095     faxHeader.iOffsetToYear = margin + 7;

  1096     faxHeader.iOffsetToHour = margin + 12;

  1097     faxHeader.iOffsetToMinute = margin + 15;

  1098 

  1099     //

  1100 	// assume we have the page info on the righthand side as pp/tt

  1101     // 54321

  1102     // fill in the separator

  1103 	//

  1104     textLine.Replace (charactersPerLine - margin - 3, 1, _L8 ("/"));

  1105 

  1106     //

  1107 	// set up the offsets to the data

  1108 	//

  1109     faxHeader.iOffsetToTotalPages = charactersPerLine - margin - 2;

  1110     faxHeader.iOffsetToCurrentPage = charactersPerLine - margin - 5;

  1111 

  1112     //

  1113     // read in the fax settings, because we want the fax ID and the user ID

  1114     //

  1115     TFaxSettings  ourFaxSettings;

  1116     TBuf8<20>  userName;

  1117    

  1118     ourFaxSettings.iFaxId.Copy(_L("+++01234 56789+++"));

  1119     userName.Copy(_L("Symbian Test Header"));

  1120 

  1121     TInt  lenID = ourFaxSettings.iFaxId.Length ();

  1122     TInt  lenUser = userName.Length ();

  1123 

  1124     //

  1125     // Fill the header line with appropriate information

  1126 	//

  1127     textLine.Replace (faxHeader.iOffsetToMinute + 4, lenID, ourFaxSettings.iFaxId);

  1128     textLine.Replace (faxHeader.iOffsetToCurrentPage - lenUser -2, lenUser, userName);

  1129 

  1130     //

  1131 	// HEADER LAYOUT NOW FINISHED

  1132 	//

  1133     // now we can write the fax header info to the header info file

  1134     //