void CPigeonScheduledSend::PopulateOffPeakListL()
{
//There are no existing off peak times set up
//So no need to remember them
iOffPeakList->Reset();
TTime t;
TDateTime d;
t.HomeTime();
t -= TTimeIntervalHours(1);
d = t.DateTime();
TTimeIntervalMinutes twoHours = 120;
TMsvOffPeakTime current(t.DayNoInWeek(), d.Hour(), d.Minute(), twoHours);
iOffPeakList->AppendL(current);
t -= TTimeIntervalDays(1);
d = t.DateTime();
TMsvOffPeakTime yesterday(t.DayNoInWeek(), d.Hour(), d.Minute(), twoHours);
iOffPeakList->AppendL(yesterday);
t += TTimeIntervalDays(2);
d = t.DateTime();
TMsvOffPeakTime tomorrow(t.DayNoInWeek(), d.Hour(), d.Minute(), twoHours);
iOffPeakList->AppendL(tomorrow);
}
// ---------------------------------------------------------------------------
// TPresCondValidity::ParseFromXMLTimeString()
// ---------------------------------------------------------------------------
//
TInt TPresCondValidity::ParseFromXMLTimeString(const TDesC& aXMLTimeString,
TTime& aUTCDateTime)
{
OPENG_DP(D_OPENG_LIT( " TPresCondValidity::ParseFromXMLTimeString()" ) );
OPENG_DP(D_OPENG_LIT( " ParseFromXMLTimeString aXMLTimeString = %S"),
&aXMLTimeString);
TInt err(KErrNone);
// Initializing the locale
TLocale myLocale, systemLocale;
myLocale.Refresh();
systemLocale.Refresh();
myLocale.SetDateFormat(EDateJapanese);
myLocale.SetDateSeparator('-',1);
myLocale.SetDateSeparator('-',2);
myLocale.SetDateSeparator('T',3);
myLocale.SetTimeFormat(ETime24);
myLocale.SetTimeSeparator(':',1);
myLocale.SetTimeSeparator(':',2);
myLocale.SetTimeSeparator(' ',3);
myLocale.Set();
TTime myTime;
TTime myUTCtime;
TChar uTCtimeSign(aXMLTimeString[23]); // 23 is ascii T
// parsing main time
TBuf<KPresDateTimeBufLength> dateTimeBuffer(aXMLTimeString);
dateTimeBuffer.Delete(KPresDTWithoutUTCLength-1,6);
dateTimeBuffer.Replace(KPresDTSeperatorPos,1,KPresSpaceString);
myTime.Parse(dateTimeBuffer);
// parsing utc time
TBuf<KPresDateTimeBufLength> uTCbuffer(aXMLTimeString);
uTCbuffer.Delete(0,KPresDTWithoutUTCLength);
myUTCtime.Parse(uTCbuffer);
TDateTime uTCDateTime = myUTCtime.DateTime();
// adding or substracting utc from main time
if(uTCtimeSign=='+') // if diff is positive
{
aUTCDateTime = myTime - TTimeIntervalHours(uTCDateTime.Hour());
aUTCDateTime = aUTCDateTime - TTimeIntervalMinutes(uTCDateTime.Minute());
}
else if(uTCtimeSign=='-')
{
aUTCDateTime = myTime + TTimeIntervalHours(uTCDateTime.Hour());
aUTCDateTime = aUTCDateTime + TTimeIntervalMinutes(uTCDateTime.Minute());
}
else
err = KErrArgument;
// putting the system locale back
systemLocale.Set();
return err;
}
TBool CHttpHdrTest::CompareDate(TDateTime aDate1, TDateTime aDate2)
{
return ((aDate1.Year() == aDate2.Year()) &&
(aDate1.Month() == aDate2.Month()) &&
(aDate1.Day() == aDate2.Day()) &&
(aDate1.Hour() == aDate2.Hour()) &&
(aDate1.Minute() == aDate2.Minute()) &&
(aDate1.Second() == aDate2.Second()) &&
(aDate1.MicroSecond() == aDate2.MicroSecond()));
}
// ---------------------------------------------------------------------------
// TPresCondValidity::LogDateTime()
// ---------------------------------------------------------------------------
//
void TPresCondValidity::LogDateTime(TDateTime aDateTime)
{
OPENG_DP(D_OPENG_LIT( " %d, %d, %d, %d, %d, %d, %d"),
aDateTime.Year(), aDateTime.Month()+1, aDateTime.Day()+1,
aDateTime.Hour(), aDateTime.Minute(), aDateTime.Second(),
aDateTime.MicroSecond() );
}
GLDEF_C void Debug( TRefByValue<const TDesC> aText, ... )
{
#ifdef WINS
VA_LIST args;
VA_START( args, aText );
TBuf<KLogLineLength> buf;
buf.FormatList( aText, args );
RFileLogger logger;
TInt ret=logger.Connect();
if (ret==KErrNone)
{
logger.SetDateAndTime( EFalse,EFalse );
logger.CreateLog( KLogFolder, KLogFileName, EFileLoggingModeAppend );
TBuf<KLogTimeFormatLength> timeStamp;
TTime now;
now.HomeTime();
TDateTime dateTime;
dateTime = now.DateTime();
timeStamp.Format( KLogTimeFormat,
dateTime.Hour(), dateTime.Minute(),
dateTime.Second(), dateTime.MicroSecond() );
buf.Insert( 0, timeStamp );
logger.Write(buf);
}
logger.Close();
VA_END( args );
#else
RDebug::Print(aText);
#endif
}
static struct tm& as_struct_tm (const time_t& t, struct tm& res)
{
TTime us = UNIX_BASE + TTimeIntervalSeconds(t);
TDateTime dt = us.DateTime();
res.tm_sec = dt.Second();
res.tm_min = dt.Minute();
res.tm_hour = dt.Hour();
res.tm_mday = dt.Day() + 1;
res.tm_mon = dt.Month();
res.tm_year = dt.Year() - 1900;
// EPOC32 counts the year day as Jan 1st == day 1
res.tm_yday = us.DayNoInYear() - 1;
// EPOC32 counts the weekdays from 0==Monday to 6==Sunday
res.tm_wday = us.DayNoInWeek() + 1;
if (res.tm_wday==7)
res.tm_wday=0; // Sunday==0 in a struct tm
// newlib just sets this field to -1
// tm_isdst doesn't really make sense here since we don't
// know the locale for which to interpret this time.
res.tm_isdst = -1;
return res;
}
// -----------------------------------------------------------------------------
// CCapInfo::WriteSolutionTagL()
// Writes SyncSolutionsService solution data to capability object.
// -----------------------------------------------------------------------------
//
void CCapInfo::WriteSolutionTagL( const TDesC& aContentName,
const TSConSolutionInfo& aSolution )
{
TRACE_FUNC_ENTRY;
_LIT( KFormatUID, "UID=0x%08x" );
_LIT( KFormatName, "Name=%S" );
_LIT( KFormatDate, "Timestamp=%04d%02d%02dT%02d%02d%02dZ" );
WriteTagL( EExt, TXmlParser::EElementBegin );
WriteValueL( EXNam, aContentName );
TFileName temp;
temp.Format( KFormatUID, aSolution.iUid );
WriteValueL( EXVal, temp );
temp.Format( KFormatName, &aSolution.iSolutionName );
WriteValueL( EXVal, temp );
if ( aSolution.iTime.Int64() != 0 )
{
// write time
TDateTime time = aSolution.iTime.DateTime();
temp.Format( KFormatDate, time.Year(), time.Month() + 1,
time.Day() + 1, time.Hour(), time.Minute(), time.Second() );
WriteValueL( EXVal, temp );
}
WriteTagL( EExt, TXmlParser::EElementEnd );
TRACE_FUNC_EXIT;
}
void MemSpyEngineUtils::FormatTimeSimple( TDes& aBuf, const TTime& aTime )
{
const TDateTime dt = aTime.DateTime();
//
_LIT( KTimeFormatSpec, "%04d%02d%02d %02d:%02d:%02d" );
aBuf.Format( KTimeFormatSpec, dt.Year(), dt.Month()+1, dt.Day()+1, dt.Hour(), dt.Minute(), dt.Second() );
}
void RTestExecuteLogServ::AddTime(TDes8& aLogBuffer)
{
TTime now;
now.UniversalTime();
TDateTime dateTime = now.DateTime();
_LIT8(KFormat,"%02d:%02d:%02d:%03d ");
// add the current time
aLogBuffer.AppendFormat(KFormat,dateTime.Hour(),dateTime.Minute(),dateTime.Second(),(dateTime.MicroSecond()/1000));
}
void CSerialWriter::AddTime(TDes8& aLogBuffer)
{
TTime now;
now.UniversalTime();
TDateTime dateTime = now.DateTime();
_LIT8(KFormat,"%02d:%02d:%02d:%03d ");
// add the current time
aLogBuffer.Append(KTEFNewLine) ;
aLogBuffer.AppendFormat(KFormat,dateTime.Hour(),dateTime.Minute(),dateTime.Second(),(dateTime.MicroSecond()/1000));
}
void CSheduleServerLog::WriteWithTimeStamp(const TDesC& aText)
{
TBuf<200> buf;
TTime now;
now.HomeTime();
TDateTime dateTime;
dateTime = now.DateTime();
buf.Format(_L("%02d.%02d:%02d:%06d "), dateTime.Hour(), dateTime.Minute(), dateTime.Second(), dateTime.MicroSecond());
Write(buf);
Write(aText);
}
void CTe_RegConcurrentTestStepBase::PrintCurrentTimeStamp(TBool aStart)
{
TTime time;
time.UniversalTime();
TDateTime dateTime = time.DateTime();
TBuf<32> timeBuf;
timeBuf.Format(_L("%02d:%02d:%02d:%03d"), dateTime.Hour(), dateTime.Minute(), dateTime.Second(), dateTime.MicroSecond());
TBuf<16> buf(aStart?_L("started"):_L("ended"));
_LIT(KTimeFormat, "%S in server %S %S at %S");
INFO_PRINTF5(KTimeFormat, &ConfigSection(), &GetServerName(), &buf, &timeBuf);
}
// -----------------------------------------------------------------------------
// CUpdateManager::StartTimer
//
// Start timer.
// -----------------------------------------------------------------------------
//
void CUpdateManager::StartTimer()
{
TTime time;
time.HomeTime();
TDateTime dateTime = time.DateTime();
iMins = dateTime.Hour() * 60 + dateTime.Minute();
TTimeIntervalMinutes interval(KMinFrequency - iMins % KMinFrequency);
time += interval;
At(time);
}
void CRuleManager::TimeFormat(const TTime& aTime,TDes8& aDes)
{
TDateTime time = aTime.DateTime();
TInt hour,minute;
hour = time.Hour() ;
minute = time.Minute() ;
aDes.AppendNum(hour);
aDes.Append(':');
aDes.AppendNum(minute);
}
CIpuTestHarness::~CIpuTestHarness()
//
// D'tor
{
TTime endtime;
endtime.UniversalTime();
// Do resource handle leak test?
if (iDoResourceLeakTest)
ResourceLeakTest();
// End of tests - see if failed or ok
if (iFailedTests->Count())
{
TestHarnessFailed();
}
else
{
TestHarnessComplete();
}
iFailedTests->ResetAndDestroy();
delete iFailedTests;
// Log finish time
TDateTime t = endtime.DateTime();
LogIt(_L("Ended @ %d:%d:%d:%d"),t.Hour(),t.Minute(),t.Second(),t.MicroSecond());
TTime difftime(endtime.Int64() - iStartTime.Int64());
t = difftime.DateTime();
LogIt(_L("Execution time %d:%d:%d:%d"),t.Hour(),t.Minute(),t.Second(),t.MicroSecond());
// Close logs and test harness
iFlogger.CloseLog();
// iTest test harness performs UHEAP MARK/UNMARK check upon creation/destruction
// therefore, it must be destroyed last since it is created first in
// CIpuTestHarness
iTest.Close();
}
LOCAL_C void TestReportLog(const TDesC8& aText)
{
TBuf8<200> buf;
TTime now;
now.UniversalTime();
TDateTime dateTime;
dateTime = now.DateTime();
buf.Format(_L8 ("%02d.%02d:%02d:%06d "),dateTime.Hour(),dateTime.Minute(),dateTime.Second(),dateTime.MicroSecond());
buf.AppendFormat(_L8("%S\015\012"),&aText);
TestRpt.Write(buf);
TestRpt.Flush();
}
// --------------------------------------------------------------------------
// CLocationGeoTagTimerAO::StartTimer
// --------------------------------------------------------------------------
//
void CLocationGeoTagTimerAO::StartTimer()
{
LOG ("CLocationGeoTagTimerAO::StartTimer(), begin");
if(!IsActive())
{
TTime hometime;
hometime.HomeTime();
//Get the current time in Hour,Minute, Second
TDateTime currentDateTime = hometime.DateTime();
TInt currentHr = currentDateTime.Hour();
TInt currentMin = currentDateTime.Minute();
TInt currentSec = currentDateTime.Second();
//3 AM in seconds
TInt targetTimeInSeconds = GEOTAGGING_TIME_IN_HOURS * HOUR_VALUE_IN_SECONDS;
TInt timeDifference = 0;
//Find the time difference in seconds between current time to 3.00 AM
//Either on same day or next day.
if ( currentHr < GEOTAGGING_TIME_IN_HOURS )
{
timeDifference = targetTimeInSeconds -
( ( currentHr * HOUR_VALUE_IN_SECONDS ) + ( currentMin * HOUR_VALUE_IN_MINUTES ) + currentSec );
}
else
{
timeDifference = ( 24 * HOUR_VALUE_IN_SECONDS - (
( currentHr * HOUR_VALUE_IN_SECONDS ) + ( currentMin * HOUR_VALUE_IN_MINUTES ) + currentSec ) ) +
targetTimeInSeconds ;
}
//Add the time difference to current time to set the target time ( 3.00 AM )
TTimeIntervalSeconds interval( timeDifference );
TTime timeToSet;
timeToSet.HomeTime();
timeToSet+= interval;
At( timeToSet );
}
LOG ("CLocationGeoTagTimerAO::StartTimer(), end");
}
void CIpuTestHarness::ConstructL(const TDesC& aTitle)
//
// Non-trivial c'tor
{
// Create iFailedTests
iFailedTests = new (ELeave) CArrayPtrFlat<CTestInfo> (KFailedTestsGranularity);
// Start up logging server connection
TBuf<64> temp(aTitle);
DefaultLogFileName(temp);
CreateFlogger(temp, EFalse, EFalse);
iStartTime.UniversalTime();
TDateTime t = iStartTime.DateTime();
LogIt(_L("Started @ %d:%d:%d:%d"),t.Hour(),t.Minute(),t.Second(),t.MicroSecond());
// Find number of open resource handles
TInt processHandleCount=0;
RThread().HandleCount(processHandleCount,iStartHandleCount);
}
/*
-----------------------------------------------------------------------
-----------------------------------------------------------------------
*/
TUint32 CZipCompressor::MsDosDateTime( TTime aTime )
{
TDateTime dateTime = aTime.DateTime();
TUint8 day = dateTime.Day() + 1;
TUint8 month = dateTime.Month() + 1;
TUint8 year = dateTime.Year() - 1980;
TUint8 seconds = dateTime.Second();
TUint8 minutes = dateTime.Minute();
TUint8 hours = dateTime.Hour();
TUint32 date = 0;
date |= ( year & 0x3f ) << 9;
date |= ( month & 0x0f ) << 5;
date |= ( day & 0x1f );
date <<= 16;
date |= ( hours & 0x1f ) << 11;
date |= minutes << 5;
date |= seconds >> 1;
return date;
}
bool_t GetDatePacked(datetime_t t, datepack_t *tp, bool_t Local)
{
TDateTime Date;
TTime ot;
if (!tp || t == INVALID_DATETIME_T) return 0;
ot = DateTimeToSymbian(t);
if (Local)
{
#ifndef SYMBIAN90
TLocale locale;
TTimeIntervalSeconds universalTimeOffset(locale.UniversalTimeOffset());
ot += universalTimeOffset;
if (locale.QueryHomeHasDaylightSavingOn())
{
TTimeIntervalHours daylightSaving(1);
ot += daylightSaving;
}
#else
RTz TzServer;
if (TzServer.Connect()==KErrNone)
{
CTzConverter* Converter = CTzConverter::NewL(TzServer);
Converter->ConvertToLocalTime(ot);
delete Converter;
TzServer.Close();
}
#endif
}
Date = ot.DateTime();
tp->Year = Date.Year();
tp->Month = (int)Date.Month() + 1;
tp->Day = Date.Day()+1;
tp->Hour = Date.Hour();
tp->Minute = Date.Minute();
tp->Second = Date.Second();
return 1;
}
// ---------------------------------------------------------------------------
// CGpxConverterAO::WriteStartingTags
// Writes header tags for GPX file
// ---------------------------------------------------------------------------
void CGpxConverterAO::WriteStartingTags()
{
LOG("CGpxConverterAO::WriteStartingTags ,begin");
TPtr8 writePtr = iWriteBuf->Des();
TPtr formatter = iFormatBuf->Des();
// write starting tags
writePtr.Copy( KTagXml );
writePtr.Append( KTagGpxStart );
iGpxFile.Write( writePtr );
writePtr.Copy( KTagMetaStart );
formatter.Format( KTagName, &iGpxFileName );
writePtr.Append( formatter );
iGpxFile.Write( writePtr );
TTime timeStamp( 0 );
timeStamp.UniversalTime();
TDateTime datetime = timeStamp.DateTime();
formatter.Format( KTagTimeStamp, datetime.Year(), datetime.Month() + 1, datetime.Day() + 1,
datetime.Hour(), datetime.Minute(), datetime.Second() );
writePtr.Copy( formatter );
iGpxFile.Write( writePtr );
if ( iBoundaries )
{
formatter.Format( KTagBounds, iBoundaries->minLatitude, iBoundaries->minLongitude,
iBoundaries->maxLatitude, iBoundaries->maxLongitude );
writePtr.Copy( formatter );
iGpxFile.Write( writePtr );
}
writePtr.Copy( KTagMetaEnd );
iGpxFile.Write( writePtr );
writePtr.Copy( KTagTrackStart );
iGpxFile.Write( writePtr );
LOG("CGpxConverterAO::WriteStartingTags ,end");
}
// -----------------------------------------------------------------------------
// CTFAStifTestLog::ConstructL
// -----------------------------------------------------------------------------
void CTFAStifTestLog::ConstructL( void )
{
TFileName fileName;
TTime time;
time.HomeTime();
TDateTime dateTime = time.DateTime();
RThread thread;
#ifdef __LOG_HTML__
_LIT( KSuffix, "html" );
#else
_LIT( KSuffix, "txt" );
#endif
fileName.Format( _L( "%02d%02d%02d_%02d%02d%02d_%x.%S" ),
dateTime.Year() - 2000, dateTime.Month() + 1, dateTime.Day() + 1,
dateTime.Hour(), dateTime.Minute(), dateTime.Second(),
(TUint)thread.Id(), &KSuffix );
iLogger = CStifLogger::NewL( _L( "c:\\logs\\testframework\\" ), fileName,
CStifLogger::ETxt, CStifLogger::EFile, ETrue, EFalse, EFalse, EFalse, EFalse );
iOverflowHandler = new ( ELeave ) TTFAOverflowHandler;
#ifdef __LOG_HTML__
iLogger->Log( _L8( "<html><head><title>TFA Log</title></head>\r\n<body>\r\n" ) );
#endif
}
const wchar *C_dir::ScanGet(dword *atts, dword *size, S_date_time *dt){
if(!find_data)
return NULL;
S_scan_data *sd = (S_scan_data*)find_data;
if(sd->index >= sd->count)
return NULL;
const TEntry &e = (*sd->list)[sd->index++];
if(atts){
*atts = 0;
if(e.IsArchive()) *atts |= C_file::ATT_ARCHIVE;
if(e.IsHidden()) *atts |= C_file::ATT_HIDDEN;
if(e.IsReadOnly()) *atts |= C_file::ATT_READ_ONLY;
if(e.IsSystem()) *atts |= C_file::ATT_SYSTEM;
if(e.IsDir()) *atts |= C_file::ATT_DIRECTORY;
}
if(size)
*size = e.iSize;
if(dt){
const TDateTime st = e.iModified.DateTime();
dt->year = word(st.Year());
dt->month = word(st.Month());
dt->day = word(st.Day());
dt->hour = word(st.Hour());
dt->minute = word(st.Minute());
dt->second = word(st.Second());
dt->sort_value = dt->GetSeconds() + dt->GetTimeZoneMinuteShift()*60;
dt->SetFromSeconds(dt->sort_value);
dt->sort_value = dt->GetSeconds();
}
TFileName fn = e.iName;
sd->tmp = (const wchar*)fn.PtrZ();
return sd->tmp;
}
TVerdict CTestExBDayLocal::doTestStepL()
/**
* @return - TVerdict code
* Override of base class pure virtual
*/
{
SetTestStepResult(EFail);
TInt numberOfCases = 0;
while (ETrue)
{
TPtrC ptrBDay = GetBDayL(numberOfCases);
if(ptrBDay==KNullDesC)
{
break;
}
INFO_PRINTF2(_L("TEST: %d"), numberOfCases+1);
iBDayLocal = FormatDateTime(ptrBDay);
TDateTime t = iBDayLocal.DateTime();
INFO_PRINTF7(_L("Birthday to be exported, Year: %d, Month: %d, Day: %d, Hr: %d, Min: %d, Sec: %d"), t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second());
iName = GetNameL(numberOfCases);
iPhone = GetPhoneL(numberOfCases);
TBuf<90> pathVCF(KExportBDayFile);
ExportItemL(pathVCF, ETrue);
// read from the disk.
ImportItemL(pathVCF, ETrue);
if(!CheckImportedBDay())
{
SetTestStepResult(EFail);
return TestStepResult();
}
numberOfCases++;
}// End Of While Loop
SetTestStepResult(EPass);
return TestStepResult();
}
// ---------------------------------------------------------------------------
// CGpxConverterAO::WriteItemToFile
// Writes single trackpoint to GPX file
// ---------------------------------------------------------------------------
void CGpxConverterAO::WriteItemToFile()
{
LOG("CGpxConverterAO::WriteItemToFile ,begin");
TTime timeStamp;
TPtr8 writePtr = iWriteBuf->Des();
TPtr formatter = iFormatBuf->Des();
if ( Math::IsNaN(iTempItem.iLatitude) || Math::IsNaN(iTempItem.iLongitude) )
{
if ( !iFixLost )
{
writePtr.Copy( KTagSegmentEnd );
iGpxFile.Write( writePtr );
iFixLost = ETrue;
}
}
else
{
if ( iFixLost )
{
writePtr.Copy( KTagSegmentStart );
iGpxFile.Write( writePtr );
iFixLost = EFalse;
}
// write single track point
// coordinates
formatter.Format( KTagTrkPointStart, iTempItem.iLatitude, iTempItem.iLongitude );
writePtr.Copy( formatter );
iGpxFile.Write( writePtr );
// elevation
if ( !Math::IsNaN( iTempItem.iAltitude ))
{
formatter.Format( KTagElevation, iTempItem.iAltitude );
writePtr.Copy( formatter );
iGpxFile.Write( writePtr );
}
// course
if ( !Math::IsNaN( iTempItem.iCourse ))
{
formatter.Format( KTagCourse, iTempItem.iCourse );
writePtr.Copy( formatter );
iGpxFile.Write( writePtr );
}
timeStamp = iTempItem.iTimeStamp;
TDateTime datetime = timeStamp.DateTime();
formatter.Format( KTagTimeStamp, datetime.Year(), datetime.Month() + 1, datetime.Day() + 1,
datetime.Hour(), datetime.Minute(), datetime.Second() );
writePtr.Copy( formatter );
iGpxFile.Write( writePtr );
if ( !Math::IsNaN( iTempItem.iAltitude ))
{
writePtr.Copy( KTagFix3D );
iGpxFile.Write( writePtr );
}
else
{
writePtr.Copy( KTagFix2D );
iGpxFile.Write( writePtr );
}
// number of satellites
formatter.Format( KTagSatellites, iTempItem.iNumSatellites );
writePtr.Copy( formatter );
iGpxFile.Write( writePtr );
// accuracy (hdop, vdop)
if ( !Math::IsNaN( iTempItem.iHdop ))
{
formatter.Format( KTagHdop, iTempItem.iHdop );
writePtr.Copy( formatter );
iGpxFile.Write( writePtr );
}
if ( !Math::IsNaN( iTempItem.iVdop ))
{
formatter.Format( KTagVdop, iTempItem.iVdop );
writePtr.Copy( formatter );
iGpxFile.Write( writePtr );
}
// end track point
writePtr.Copy( KTagTrkPointEnd );
iGpxFile.Write( writePtr );
}
LOG("CGpxConverterAO::WriteItemToFile ,end");
}
// print a date and time to log in a readable format:
void LbsTestUtilities::PrintfDateTimeToDebugLog(TTime aTime)
{
TDateTime datetime = aTime.DateTime();
TESTLOG8(ELogP2,"%d :%d :%d :%d on %d/%d/%d", datetime.Hour(), datetime.Minute(), datetime.Second(), datetime.MicroSecond(), datetime.Day() + 1, datetime.Month() + 1, datetime.Year());
}
TVerdict CTestImpRevLocal::doTestStepL()
/**
* @return - TVerdict code
* Override of base class pure virtual
*/
{
SetTestStepResult(EFail);
TInt numberOfCases = 0;
while(ETrue)
{
TBuf<90> config(KImportRevLocal);
TPtrC ptrexpUTC = GetExpectedUTCFromIniL(numberOfCases, config, EFalse);
if(ptrexpUTC==KNullDesC)
{
break;
}
INFO_PRINTF2(_L("TEST: %d"), numberOfCases+1);
iExpectedUTC = FormatDateTime(ptrexpUTC);
TBuf<80> pathVCF(KPathImportRevLocal);
OpenVCFAndImportItemL(pathVCF, iFsSession, numberOfCases); // Imports vcf
TDateTime t = iTimeFromImport.DateTime();
TDateTime t1 = iExpectedUTC.DateTime();
INFO_PRINTF7(_L("Imported Date Year: %d, Month: %d, Day: %d, Imported Time Hr: %d, Min: %d, Sec: %d "), t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second());
INFO_PRINTF7(_L("Expected Date Year: %d, Month: %d, Day: %d, Expected Time Hr: %d, Min: %d, Sec: %d "), t1.Year(), t1.Month(), t1.Day(), t1.Hour(), t1.Minute(), t1.Second());
if (iExpectedUTC==iTimeFromImport) // checks if imported time is correct
{
INFO_PRINTF1(_L("Imported Time as local (correct)"));
SetTestStepResult(EPass);
}
else
{
INFO_PRINTF1(_L("Imported Time not imported as local (NOT CORRECT)"));
SetTestStepResult(EFail);
return TestStepResult();
}
numberOfCases++;
}
return TestStepResult();
}
void TAzenqosEngineUtils::MakeTimeStrFile(TTime &time,TDes& str) //str should be at least 19 in length
{
TDateTime date = time.DateTime();
str.Format(KTimeStampFileFormat,date.Year()%2000,date.Month()+1,date.Day()+1,date.Hour(),date.Minute(),date.Second());
}
TVerdict CTestExRevUTC::doTestStepL()
/**
* @return - TVerdict code
* Override of base class pure virtual
*/
{
SetTestStepResult(EFail);
TBuf<90> pathVCF(KExportRevUTCFile);
ExportItemL(pathVCF, EFalse);
// read from the disk.
ImportItemL(pathVCF,EFalse);
TDateTime t = iRecordedTime.DateTime();
TDateTime t1 = iTimeFromImport.DateTime();
INFO_PRINTF7(_L("Recorded Last Modified Date Year: %d, Month: %d, Day: %d, Recorded Time Hr: %d, Min: %d, Sec: %d "), t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second());
INFO_PRINTF7(_L("Imported Last Modified Date Year: %d, Month: %d, Day: %d, Imported Time Hr: %d, Min: %d, Sec: %d "), t1.Year(), t1.Month(), t1.Day(), t1.Hour(), t1.Minute(), t1.Second());
TTimeIntervalSeconds secondsDifference;
User::LeaveIfError(iTimeFromImport.SecondsFrom(iRecordedTime, secondsDifference));
TInt difference = secondsDifference.Int();
if (difference < 2 && difference > -2)
{
INFO_PRINTF1(_L("Recorded and Imported DateTime match"));
SetTestStepResult(EPass);
}
else
{
INFO_PRINTF1(_L("Recorded and Imported DateTime does not match"));
SetTestStepResult(EFail);
}
return TestStepResult();
}
void TAzenqosEngineUtils::MakeTimeStrMilli(TTime &time,TDes& str) //str should be at least 19 in length
{
const TInt KThousand = 1000;
TDateTime date = time.DateTime();
str.Format(KTimeStampMillisecFormat,date.Year()%2000,date.Month()+1,date.Day()+1,date.Hour(),date.Minute(),date.Second(),date.MicroSecond()*KThousand);
}
