--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/pimappsupport/chinesecalendaralg/tsrc/ConvertDates.cpp	Fri Mar 12 15:42:35 2010 +0200
@@ -0,0 +1,910 @@
+// Copyright (c) 2002-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:
+//
+
+#include "ConvertDates.h"
+
+// Constants 
+const TInt KFirstConvertYear = 0;
+const TInt KFromOffset = 0;
+const TInt KToOffset = 5;
+const TInt KCycleOffset = 10;
+const TInt KYearOffset = 13;
+const TInt KMnthOffset = 19;
+const TInt KLeapMonthOffset = 22;
+const TInt KDyOffset = 24;
+const TInt KCycleLen = 2;
+const TInt KSignLen = 1;
+const TInt KYearLen = 5;
+const TInt KMonthLen = 2;
+const TInt KDayLen = 2;
+//
+_LIT(KRoot,						"C:\\");
+_LIT(KSpace,					" ");
+_LIT(KResult,					" Result ");
+_LIT(KTestHeader,				"Test Results");
+_LIT(KFileNotPresent,			"test file %S not present - test failed\n");
+_LIT(KCalconDirectory,			"c:\\calcontest\\");
+_LIT(KCalconLogFileDirectory,	"c:\\calcon\\");
+_LIT(KCalconLogFile,			"c:\\calcon\\calcon.txt");
+_LIT(KInputFile1,				"z:\\calcontest\\input1.txt");
+_LIT(KOutputFile1,				"c:\\calcontest\\output1.txt");
+_LIT(KInputFile2,				"z:\\calcontest\\input2.txt");
+_LIT(KOutputFile2,				"c:\\calcontest\\output2.txt");
+_LIT(KOutputFileRef1,			"z:\\calcontest\\output1REFERENCE.txt");
+_LIT(KOutputFileRef2,			"z:\\calcontest\\output2REFERENCE.txt");
+_LIT8(KImcvCRLF,				"\r\n");
+_LIT8(KOutOfRange,				" *** Out of range ***");
+
+
+//
+// Construction/Destruction
+//
+
+CConvertDates::CConvertDates() : iTest(_L("Calcon Test"))
+	{
+	}
+
+CConvertDates::~CConvertDates()
+	{
+	if (iCalendarConverter)
+		delete iCalendarConverter;
+	iInputFile.Close();
+	iOutputFile.Close();
+	iLogger.Close();
+	iRFSession.Close();
+	}
+
+CConvertDates* CConvertDates::NewL()
+	{
+	CConvertDates* self = CConvertDates::NewLC();
+	CleanupStack::Pop();
+	return self;
+	}
+
+CConvertDates* CConvertDates::NewLC()
+	{
+	CConvertDates* self = new(ELeave) CConvertDates;
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+void CConvertDates::ConstructL()
+	{
+	User::LeaveIfError(iRFSession.Connect());
+	iRFSession.SetSessionPath(KRoot);
+	iRFSession.MkDirAll(KCalconLogFileDirectory);			// ignore errors -- any FS errors will present themselves later
+	iRFSession.MkDirAll(KCalconDirectory);
+
+	if	(iLogger.LogValid())
+		iLogger.CloseLog();
+	TParse p;
+	p.Set(KCalconLogFile, NULL, NULL);
+	iLogger.Connect();
+	iLogger.CreateLog(KCalconLogFileDirectory, p.NameAndExt(), EFileLoggingModeOverwrite);
+	iLogger.SetDateAndTime(EFalse, EFalse);
+	iLogger.Write(KTestHeader);
+
+	iCalendarConverter=CChineseCalendarConverter::NewL();
+	}
+
+void CConvertDates::ConvertL(TInt aInput)
+	{
+	iInputFileNumber=aInput;
+
+	if (iInputFileNumber==1)
+		iTest.Printf(_L("Generating c:\\output1.txt\n"));
+	else
+		iTest.Printf(_L("Generating c:\\output2.txt\n"));
+
+	TBuf8<100> logLine;
+	TBuf<64> errBuf;
+	// open the input and output files
+	OpenFilesL();
+
+	TInt fileErr = KErrNone;
+	while(fileErr == KErrNone)
+		{
+		// read date from the input file
+		fileErr = ReadLine(iInputFile, iDateLine);
+		if	(fileErr==KErrNone)
+			{
+			// get the cal types to convert from and to
+			TRAPD(err,GetCalL(iDateLine));
+			if	(err)
+				{
+				errBuf.Format(_L("\r\nError get calendar conversion type %d\r\n"),err);
+				iLogger.Write(errBuf);
+				}
+			else
+				{
+				// do the conversion
+				TBool success=Cal1ToCal2();
+
+				// set the cal types to convert from and to
+				logLine.Zero();
+				TRAP(err,SetCalL(logLine,success));
+				if	(err)
+					{
+					errBuf.Format(_L("\r\nError set calendar conversion type %d\r\n"),err);
+					iDateLine.Append(errBuf);
+					}
+				else
+					{
+					iDateLine.Append(logLine);
+					iDateLine.Append(_L8("\r\n"));
+					iLogger.Write(iDateLine);
+					if	(iOutputFile.Write(iDateLine))
+						{
+						User::Leave(KErrCorrupt);
+						}
+					}
+				}
+			}
+		}
+	}
+
+void CConvertDates::OpenFilesL()
+	{
+	TInt err=KErrNone;
+	if (iInputFileNumber==1)
+		{
+		err = iInputFile.Open(iRFSession, KInputFile1, EFileStreamText|EFileRead|EFileShareExclusive);
+		if (err)
+			{
+			if(KErrNotFound == err)
+				{
+				iTest.Printf(KFileNotPresent,&(KInputFile1));
+				}
+			User::Leave(err);
+			}
+		err = iOutputFile.Replace(iRFSession, KOutputFile1, EFileStreamText|EFileWrite|EFileShareExclusive);
+		User::LeaveIfError(err);
+		}
+	else
+		{
+		err = iInputFile.Open(iRFSession, KInputFile2, EFileStreamText|EFileRead|EFileShareExclusive);
+		if (err)
+			{
+			if(KErrNotFound == err)
+				{
+				iTest.Printf(KFileNotPresent,&(KInputFile2));
+				}
+			User::Leave(err);
+			}
+		err = iOutputFile.Replace(iRFSession, KOutputFile2, EFileStreamText|EFileWrite|EFileShareExclusive);
+		User::LeaveIfError(err);
+		}
+	}
+
+void CConvertDates::GetCalL(TDes8& aDateToConvert)
+	{
+	TInt dateError=KErrNone;
+	TLex8 lexCycle(aDateToConvert.Mid(KCycleOffset,KCycleLen));
+	TLex8 lexYear(aDateToConvert.Mid(KYearOffset,KYearLen));
+	TLex8 lexMonth(aDateToConvert.Mid(KMnthOffset,KMonthLen));
+	TLex8 lexDay(aDateToConvert.Mid(KDyOffset,KDayLen));
+
+	// get cycle
+	if	(lexCycle.Val(iChinDateOut.iCycle) != KErrNone)
+		{
+		User::Leave(KErrCorrupt);
+		}
+	// get year
+	if	(lexYear.Val(iArithDateOut.iYear) != KErrNone)
+		{
+		User::Leave(KErrGeneral);
+		}
+	iChinDateOut.iYear = iArithDateOut.iYear;
+	// get month
+	if	(lexMonth.Val(iArithDateOut.iMonth) != KErrNone)
+		{
+		User::Leave(KErrGeneral);
+		}
+	iChinDateOut.iMonth = iArithDateOut.iMonth;
+	// get leap month
+	if	(aDateToConvert[KLeapMonthOffset] == 't')
+		{
+		iChinDateOut.iLeapMonth = ETrue;
+		}
+	else
+		{
+		iChinDateOut.iLeapMonth = EFalse;
+		}
+	// get day
+	if	(lexDay.Val(iArithDateOut.iDay) != KErrNone)
+		{
+		User::Leave(KErrCorrupt);
+		}
+	iChinDateOut.iDay = iArithDateOut.iDay;
+
+
+	switch(aDateToConvert[KFromOffset])
+		{
+	case 'g':	//iArithDateOut contains the date to convert from
+		iCalTypeFrom = EGreg;
+		break;
+	case 'c':
+		iCalTypeFrom = EChin;
+		break;
+	default:
+		dateError = KErrCorrupt;
+		break;
+		}
+
+	if	(dateError)
+		User::Leave(dateError);
+
+	switch(aDateToConvert[KToOffset])
+		{
+	case 'g':
+		iCalTypeTo = EGreg;
+		break;
+	case 'c':
+		iCalTypeTo = EChin;
+		break;
+	default:
+		break;
+		}
+	}
+
+TBool CConvertDates::Cal1ToCal2()
+	{
+	switch(iCalTypeFrom)
+		{
+	case EGreg:
+		{
+		switch(iCalTypeTo)
+			{
+		case EChin:
+			{	//iArithDateOut contains the date to convert from
+			TDateTime dt(iArithDateOut.iYear, (TMonth)(iArithDateOut.iMonth-1), iArithDateOut.iDay-1, 0,0,0,0);
+			CChineseCalendarConverter* c=iCalendarConverter;
+			TRAPD(err,c->DateTimeToChineseL(dt, iChinDateOut));
+			if (err)
+				return EFalse;
+			break;
+			}
+		default:
+			break;
+			}
+		}
+		break;
+	case EChin:
+		{
+		switch(iCalTypeTo)
+			{	//iArithDateOut contains the date to convert from
+			case EGreg:
+				{
+				CChineseCalendarConverter* c=iCalendarConverter;
+				TDateTime dt(0,EJanuary,0,0,0,0,0);
+				TRAPD(err,c->ChineseToDateTimeL(iChinDateOut, dt));
+				if (err)
+					return EFalse;
+				iArithDateOut.iYear=dt.Year();
+				iArithDateOut.iMonth=(TInt)(dt.Month())+1;
+				iArithDateOut.iDay=dt.Day()+1;
+				break;
+				}
+			default:
+				break;
+			}
+		}
+		break;
+	default:
+		break;
+		}
+	return ETrue;
+	}
+
+
+void CConvertDates::SetCalL(TDes8& aConvertedDate, TBool aSuccess)
+	{
+	TArithmeticalDate Date;
+	TChineseDate ChinDate;
+	TBuf8<KYearLen> TempDate;
+
+	switch(iCalTypeFrom)
+		{
+	case EGreg:
+		{
+		switch(iCalTypeTo)
+			{
+		case EChin:
+			ChinDate=iChinDateOut;
+			break;
+		default:
+			break;
+			}
+		}
+		break;
+	case EChin:
+		{
+		switch(iCalTypeTo)
+			{
+		case EGreg:
+			Date=iArithDateOut;
+			TempDate.Copy(_L("greg "));
+		default:
+			break;
+			}
+		}
+		break;
+	default:
+		break;
+		}
+
+	if (!aSuccess)
+		{
+		aConvertedDate.Append(KOutOfRange);
+		return;
+		}
+	
+	if	(iCalTypeTo == EChin)
+		{
+		TBuf8<10> TempFormatStr;
+
+		TempFormatStr.FillZ();
+		TempFormatStr.Format(_L8("%%0%dd"),KCycleLen);
+		TempDate.FillZ();
+		TempDate.Format(TempFormatStr,ChinDate.iCycle);
+		aConvertedDate.Append(KResult);
+		aConvertedDate.Append(TempDate);
+		aConvertedDate.Append(KSpace);
+
+		TempDate.FillZ();
+		TempDate.Format(_L8("+"));
+		aConvertedDate.Append(TempDate);
+
+		TempFormatStr.FillZ();
+		TempFormatStr.Format(_L8("%%0%dd"),KYearLen - KSignLen);
+		TempDate.FillZ();
+		TempDate.Format(TempFormatStr,ChinDate.iYear);
+		aConvertedDate.Append(TempDate);
+		aConvertedDate.Append(KSpace);
+
+		TempFormatStr.FillZ();
+		TempFormatStr.Format(_L8("%%0%dd"),KMonthLen);
+		TempDate.FillZ();
+		TempDate.Format(TempFormatStr,ChinDate.iMonth);
+		aConvertedDate.Append(TempDate);
+		aConvertedDate.Append(KSpace);
+
+		TempDate.FillZ();
+		if	(ChinDate.iLeapMonth == EFalse)
+			{
+			TempDate.Format(_L8("f"));
+			}
+		else
+			{
+			TempDate.Format(_L8("t"));
+			}
+		aConvertedDate.Append(TempDate);
+		aConvertedDate.Append(KSpace);
+
+		TempFormatStr.FillZ();
+		TempFormatStr.Format(_L8("%%0%dd"),KDayLen);
+		TempDate.FillZ();
+		TempDate.Format(TempFormatStr,ChinDate.iDay);
+		aConvertedDate.Append(TempDate);
+		}
+	else
+		{
+		TBuf8<10> TempFormatStr;
+
+		if	(Date.iYear >= KFirstConvertYear)
+			{
+			TempDate.Format(_L8("+"));
+			}
+		else
+			{
+			TempDate.Format(_L8("-"));
+			}
+		aConvertedDate.Append(KResult);
+		aConvertedDate.Append(TempDate);
+
+		TempFormatStr.FillZ();
+		TempFormatStr.Format(_L8("%%0%dd"),KYearLen - KSignLen);
+		TempDate.FillZ();
+		if	(Date.iYear >= KFirstConvertYear)
+			{
+			TempDate.Format(TempFormatStr,Date.iYear);
+			}
+		else
+			{
+			TempDate.Format(TempFormatStr,-Date.iYear);
+			}
+		aConvertedDate.Append(TempDate);
+		aConvertedDate.Append(KSpace);
+
+		TempFormatStr.FillZ();
+		TempFormatStr.Format(_L8("%%0%dd"),KMonthLen);
+		TempDate.FillZ();
+		TempDate.Format(TempFormatStr,Date.iMonth);
+		aConvertedDate.Append(TempDate);
+		aConvertedDate.Append(KSpace);
+
+		TempFormatStr.FillZ();
+		TempFormatStr.Format(_L8("%%0%dd"),KDayLen);
+		TempDate.FillZ();
+		TempDate.Format(TempFormatStr,Date.iDay);
+		aConvertedDate.Append(TempDate);
+		}
+	}
+
+void CConvertDates::SetCal16L(TDes& aConvertedDate, TBool /*aSuccess*/)
+	{
+	TArithmeticalDate Date;
+	TChineseDate ChinDate;
+	TBuf<KYearLen> TempDate;
+
+	switch(iCalTypeFrom)
+		{
+	case EGreg:
+		{
+		switch(iCalTypeTo)
+			{
+		case EChin:
+			ChinDate=iChinDateOut;
+			break;
+		default:
+			break;
+			}
+		}
+		break;
+	case EChin:
+		{
+		switch(iCalTypeTo)
+			{
+		case EGreg:
+			Date=iArithDateOut;
+			TempDate.Copy(_L("greg "));
+		default:
+			break;
+			}
+		}
+		break;
+	default:
+		break;
+		}
+
+	if	(iCalTypeTo == EChin)
+		{
+		TBuf<10> TempFormatStr;
+
+		TempFormatStr.FillZ();
+		TempFormatStr.Format(_L("%%0%dd"),KCycleLen);
+		TempDate.FillZ();
+		TempDate.Format(TempFormatStr,ChinDate.iCycle);
+		aConvertedDate.Append(_L(" Chinese "));
+		aConvertedDate.Append(TempDate);
+		aConvertedDate.Append(KSpace);
+
+		TempDate.FillZ();
+		TempDate.Format(_L("+"));
+		aConvertedDate.Append(TempDate);
+
+		TempFormatStr.FillZ();
+		TempFormatStr.Format(_L("%%0%dd"),KYearLen - KSignLen);
+		TempDate.FillZ();
+		TempDate.Format(TempFormatStr,ChinDate.iYear);
+		aConvertedDate.Append(TempDate);
+		aConvertedDate.Append(KSpace);
+
+		TempFormatStr.FillZ();
+		TempFormatStr.Format(_L("%%0%dd"),KMonthLen);
+		TempDate.FillZ();
+		TempDate.Format(TempFormatStr,ChinDate.iMonth);
+		aConvertedDate.Append(TempDate);
+		aConvertedDate.Append(KSpace);
+
+		TempDate.FillZ();
+		if	(ChinDate.iLeapMonth == EFalse)
+			{
+			TempDate.Format(_L("f"));
+			}
+		else
+			{
+			TempDate.Format(_L("t"));
+			}
+		aConvertedDate.Append(TempDate);
+		aConvertedDate.Append(KSpace);
+
+		TempFormatStr.FillZ();
+		TempFormatStr.Format(_L("%%0%dd"),KDayLen);
+		TempDate.FillZ();
+		TempDate.Format(TempFormatStr,ChinDate.iDay);
+		aConvertedDate.Append(TempDate);
+		}
+	else
+		{
+		TBuf<10> TempFormatStr;
+
+		if	(Date.iYear >= KFirstConvertYear)
+			{
+			TempDate.Format(_L("+"));
+			}
+		else
+			{
+			TempDate.Format(_L("-"));
+			}
+		aConvertedDate.Append(_L("Greg "));
+		aConvertedDate.Append(TempDate);
+
+		TempFormatStr.FillZ();
+		TempFormatStr.Format(_L("%%0%dd"),KYearLen - KSignLen);
+		TempDate.FillZ();
+		if	(Date.iYear >= KFirstConvertYear)
+			{
+			TempDate.Format(TempFormatStr,Date.iYear);
+			}
+		else
+			{
+			TempDate.Format(TempFormatStr,-Date.iYear);
+			}
+		aConvertedDate.Append(TempDate);
+		aConvertedDate.Append(KSpace);
+
+		TempFormatStr.FillZ();
+		TempFormatStr.Format(_L("%%0%dd"),KMonthLen);
+		TempDate.FillZ();
+		TempDate.Format(TempFormatStr,Date.iMonth);
+		aConvertedDate.Append(TempDate);
+		aConvertedDate.Append(KSpace);
+
+		TempFormatStr.FillZ();
+		TempFormatStr.Format(_L("%%0%dd"),KDayLen);
+		TempDate.FillZ();
+		TempDate.Format(TempFormatStr,Date.iDay);
+		aConvertedDate.Append(TempDate);
+		}
+	}
+
+//
+// Read line of test from file
+//
+TInt CConvertDates::ReadLine(RFile& aInputFile, TBuf8<KDateLen>& aDateLine)
+    {
+    TInt err = KErrNone;
+
+    //  Read into the buffer
+    TBuf8<256> buffer;              // Max read of the Read() function..    
+    aDateLine.Zero();
+
+    //  Get the current file position
+    TInt filePos = 0;
+    aInputFile.Seek(ESeekCurrent, filePos);
+
+    //  Read the buffer
+    err = aInputFile.Read(buffer);
+    
+    //end of file?
+    TInt s = buffer.Length();
+    if	( s == 0)
+        err = KErrEof;
+     
+    if	(err == KErrNone)
+        {
+        //  Copy to the lfcr and then set the file pointer
+        //  to the point after that...
+        TInt pos = buffer.Find(KImcvCRLF);
+        if	( pos != -1)
+            {
+            aDateLine.Justify(buffer, pos, ELeft, ' ');
+            filePos += (pos+2);
+
+            //  Set the file pointer back to after the lfcr..
+            aInputFile.Seek(ESeekStart, filePos);                
+            }
+        //  Else fill the whole buffer 256 chars..
+        else
+            {
+            aDateLine.Copy(buffer);
+            }
+        }
+    return err;
+    }
+
+TBool CConvertDates::IntegrityTestL()
+	{
+	iTest.Printf(_L("Integrity test:\n"));
+	iTest.Printf(_L("Stepping through every possible Chinese date in the range of the calendar\n"));
+	iTest.Printf(_L("checking that either the Chinese date is invalid, or that the\n"));
+	iTest.Printf(_L("returned Julian Day is one greater than the previous Julian Day."));
+
+	TDateTime dateTime;
+	CChineseCalendarConverter* chineseCalendar=CChineseCalendarConverter::NewL();
+
+	TChineseDate start;
+	TChineseDate finish;
+	chineseCalendar->DateRange(start, finish);
+	TDateTime startDT;
+	TDateTime finishDT;
+	chineseCalendar->DateRange(startDT, finishDT);
+
+	TBuf<KDateLen>	outputBuf;	
+	iCalTypeFrom=EChin;
+	iCalTypeTo=EGreg;
+	iArithDateOut.iDay=startDT.Day()+1;
+	iArithDateOut.iMonth=(TInt)startDT.Month()+1;
+	iArithDateOut.iYear=startDT.Year();
+	SetCal16L(outputBuf);
+	iChinDateOut=start;
+	iCalTypeFrom=EGreg;
+	iCalTypeTo=EChin;
+	SetCal16L(outputBuf);
+	iTest.Printf(_L("\n\nCalendar start date\n"));
+	iTest.Printf(outputBuf);
+
+	chineseCalendar->DateTimeToChineseL(startDT,start);
+	TReal startJulian=chineseCalendar->JulianDate();
+	chineseCalendar->DateTimeToChineseL(finishDT,finish);
+	TReal finishJulian=chineseCalendar->JulianDate();
+	iTest.Printf(_L("\nJulian: %f"),startJulian);
+
+	chineseCalendar->DateRange(start, finish);
+	//can check here that start & finish do not change
+
+	outputBuf.SetLength(0);
+	iCalTypeFrom=EChin;
+	iCalTypeTo=EGreg;
+	iArithDateOut.iDay=finishDT.Day()+1;
+	iArithDateOut.iMonth=(TInt)finishDT.Month()+1;
+	iArithDateOut.iYear=finishDT.Year();
+	SetCal16L(outputBuf);
+	iChinDateOut=finish;
+	iCalTypeFrom=EGreg;
+	iCalTypeTo=EChin;
+	SetCal16L(outputBuf);
+	iTest.Printf(_L("\n\nCalendar end date\n"));
+	iTest.Printf(outputBuf);
+	iTest.Printf(_L("\nJulian: %f\n\n"),finishJulian);
+
+	start.iCycle--; //check that errors are return for date earlier than the lower bound
+	finish.iCycle+=2;//check that errors are return for date later than the upper bound
+
+	TInt err=KErrNone;
+
+	do
+		{
+		NextDate(start);
+		TRAP(err,chineseCalendar->ChineseToDateTimeL(start, dateTime));
+		}
+	while (err==KErrArgument);
+
+	TReal currentJulian=chineseCalendar->JulianDate();
+
+	iState=EChangeDay;
+
+	TDateTime lowerBound;
+	TDateTime upperBound;
+	chineseCalendar->DateRange(lowerBound, upperBound);
+	TChineseDate lowerBoundChin;
+	TChineseDate upperBoundChin;
+	chineseCalendar->DateRange(lowerBoundChin, upperBoundChin);
+	TRAP(err,chineseCalendar->ChineseToDateTimeL(upperBoundChin, dateTime));
+
+	while (start.iCycle<finish.iCycle)
+		{
+		NextDate(start);
+		TRAP(err,chineseCalendar->ChineseToDateTimeL(start, dateTime));
+		
+		if (err==KErrNone)
+			{
+			TReal julian=chineseCalendar->JulianDate();
+		
+			if (julian!=++currentJulian)
+				{
+				iTest.Printf(_L("%f %f"),julian,currentJulian);
+
+				delete chineseCalendar;
+				return EFalse;
+				}
+			}
+
+		//	chineseCalendar.GetDate(checkDate);
+		//	if (!(checkDate==start))
+		//		User::Invariant();
+		}
+	delete chineseCalendar;
+	return ETrue;
+	}
+
+void CConvertDates::NextDate(TChineseDate& aDate)
+	{
+top:
+	TBool cont=EFalse;
+
+	switch (iState)
+		{
+		case EChangeDay:
+			if (aDate.iDay==30)
+				{
+				iState=EChangeMonth;
+				aDate.iDay=1;
+				cont=ETrue;
+				}
+			else
+				{
+				aDate.iDay++;
+				}
+			break;
+		case EChangeMonth:
+			if (aDate.iLeapMonth)
+				{
+				aDate.iLeapMonth=EFalse;
+				if (aDate.iMonth==12)
+					{
+					iState=EChangeYear;
+					aDate.iMonth=1;
+					cont=ETrue;
+					}
+				else
+					{
+					aDate.iMonth++;
+					iState=EChangeDay;
+					}
+				}
+			else
+				{
+				aDate.iLeapMonth=ETrue;
+				iState=EChangeDay;
+				}
+			break;
+		case EChangeYear:
+			if (aDate.iYear==60)
+				{
+				iState=EChangeCycle;
+				aDate.iYear=1;
+				cont=ETrue;
+				}
+			else
+				{
+				aDate.iYear++;
+				iState=EChangeDay;
+				}
+			break;
+		case EChangeCycle:
+			aDate.iCycle++;
+			iState=EChangeDay;
+			break;
+		default:
+			User::Invariant();
+		}
+	if (cont) goto top;
+	}
+
+				
+
+//
+// Construction/Destruction
+//
+
+//------------------------------------------------------
+// Class:       TArithmeticalDate
+// Function:    TArithmeticalDate
+// Arguments:   None
+//
+// Comments:    Constructor
+//
+// Return:      None
+//------------------------------------------------------
+TArithmeticalDate::TArithmeticalDate()
+	{
+	}
+
+//------------------------------------------------------
+// Class:       TArithmeticalDate
+// Function:    operator ==
+// Arguments:   const TArithmeticalDate &
+//
+// Comments:    overloaded == operator
+//
+// Return:      TBool - ETrue if both the TArithmeticalDate 
+//				classes are the same
+//------------------------------------------------------
+TBool TArithmeticalDate::operator ==(const TArithmeticalDate &aDate) const
+	{
+	TBool rtn = ETrue;
+	if(iYear != aDate.iYear)
+		{
+		rtn = EFalse;
+		}
+	if(iMonth != aDate.iMonth)
+		{
+		rtn = EFalse;
+		}
+	if(iDay != aDate.iDay)
+		{
+		rtn = EFalse;
+		}
+	return rtn;
+	}
+
+TBool CConvertDates::CompareL()
+	{
+	iInputFile.Close();
+	iOutputFile.Close();
+	
+	TBool ret=ETrue;
+	TInt err=KErrNone;
+
+	if (iInputFileNumber==1)
+		{
+		err = iOutputFile.Open(iRFSession, KOutputFile1, EFileStreamText|EFileRead|EFileShareExclusive);
+		if (err)
+			{
+			if(KErrNotFound == err)
+				{
+				iTest.Printf(KFileNotPresent,&(KOutputFile1));
+				}
+			User::Leave(err);
+			}
+		err = iOutputFileRef.Open(iRFSession, KOutputFileRef1, EFileStreamText|EFileRead|EFileShareExclusive);
+		if (err)
+			{
+			if(KErrNotFound == err)
+				{
+				iTest.Printf(KFileNotPresent,&(KOutputFileRef1));
+				}
+			User::Leave(err);
+			}
+		}
+	else
+		{
+		err = iOutputFile.Open(iRFSession, KOutputFile2, EFileStreamText|EFileRead|EFileShareExclusive);
+		if (err)
+			{
+			if(KErrNotFound == err)
+				{
+				iTest.Printf(KFileNotPresent,&(KOutputFile2));
+				}
+			User::Leave(err);
+			}
+		err = iOutputFileRef.Open(iRFSession, KOutputFileRef2, EFileStreamText|EFileRead|EFileShareExclusive);
+		if (err)
+			{
+			if(KErrNotFound == err)
+				{
+				iTest.Printf(KFileNotPresent,&(KOutputFileRef2));
+				}
+			User::Leave(err);
+			}
+		}
+	
+	TBuf8<KDateLen>	outputBuf;
+	TBuf8<KDateLen>	outputBufRef;
+
+	while (err==KErrNone)
+		{
+		err=ReadLine(iOutputFile,outputBuf);
+		if (err==KErrNone)
+			{
+			ReadLine(iOutputFileRef,outputBufRef);
+			TInt m=outputBuf.FindF(KOutOfRange);
+			if (m==KErrNotFound)
+				{
+				if (outputBuf.CompareF(outputBufRef)!=0)
+					{
+					ret=EFalse;
+					break;
+					}	
+				}
+			}
+		}
+	iOutputFile.Close();
+	iOutputFileRef.Close();
+	return ret;
+	}