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()));
}
void CBuddycloudListComponent::TimerExpired(TInt aExpiryId) {
if(aExpiryId == KDragTimerId) {
#ifdef __SERIES60_40__
if(iDraggingAllowed) {
iDragVelocity = iDragVelocity * 0.95;
iScrollbarHandlePosition += TInt(iDragVelocity);
CBuddycloudListComponent::RepositionItems(false);
RenderScreen();
if(Abs(iDragVelocity) > 0.05) {
iDragTimer->After(50000);
}
}
#endif
}
else if(aExpiryId == KTimeTimerId) {
#ifdef __3_2_ONWARDS__
HBufC* aTitle = iEikonEnv->AllocReadResourceLC(R_LOCALIZED_STRING_APPNAME);
SetTitleL(*aTitle);
CleanupStack::PopAndDestroy();
#else
TTime aTime;
aTime.HomeTime();
TBuf<32> aTextTime;
aTime.FormatL(aTextTime, _L("%J%:1%T%B"));
SetTitleL(aTextTime);
TDateTime aDateTime = aTime.DateTime();
iTimer->After((60 - aDateTime.Second() + 1) * 1000000);
#endif
}
}
// ---------------------------------------------------------------------------
// 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() );
}
// -----------------------------------------------------------------------------
// 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;
}
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;
}
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
}
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);
}
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();
}
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();
}
// --------------------------------------------------------------------------
// 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 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 FmBkupEnginePrivate::GetRestoreInfoArray( QList<FmBkupDrivesAndOperation* > drivesAndOperationList,
QList< FmRestoreInfo > &restoreInfoList,
const QString& aDrive )
{
int targetDrive = DriverNameToNumber( aDrive );
restoreInfoList.clear();
///////
iDrvAndOpList->Reset();
iBkupCategoryList->ResetAndDestroy();
for( QList<FmBkupDrivesAndOperation* >::iterator it = drivesAndOperationList.begin();
it != drivesAndOperationList.end(); ++it )
{
FmBkupDrivesAndOperation* fmDrvAndOp = *it;
TBkupDrivesAndOperation drvAndOp;
drvAndOp.setOwnerDataType( fmDrvAndOp->ownerDataType() );
drvAndOp.setDrvCategories( fmDrvAndOp->drvCategories() );
iDrvAndOpList->AppendL( drvAndOp );
}
////////
CMMCScBkupOpParamsRestoreFull* params =
CMMCScBkupOpParamsRestoreFull::NewL(
iDrvAndOpList, FmBkupEngine::EBUCatAllSeparately );
CleanupStack::PushL( params );
// Get list of all archives
RPointerArray< CMMCScBkupArchiveInfo > archives;
TCleanupItem cleanupItem( ResetAndDestroyArchives, &archives );
CleanupStack::PushL( cleanupItem );
iBkupEngine->ListArchivesL(
archives,
params,
AllowedDriveAttMatchMask(),
targetDrive );
// Fill restore info
TInt count( archives.Count() );
// restoreInfoList.ReserveL( count );
for( TInt i( 0 ); i < count; ++i )
{
// Content
CMMCScBkupArchiveInfo& archiveInfo( *archives[ i ] );
TUint32 iContent = BkupToFmgrMask( archiveInfo.Category().iFlags );
TTime iTime = archiveInfo.DateTime();
TInt iDrive = archiveInfo.Drive();
TDateTime iDateTime = iTime.DateTime();
int h = iDateTime.Hour();
int m = iDateTime.Minute();
int s = iDateTime.Second();
int year = iDateTime.Year();
int month = iDateTime.Month() + 1;
int day = iDateTime.Day()+1;
QTime time( h, m, s);
QDate date( year, month, day );
QDateTime dateTime( date, time );
dateTime = dateTime.toLocalTime();
FmRestoreInfo restoreInfo( iContent, dateTime, NumberToDriverName( iDrive ) );
restoreInfoList.append( restoreInfo );
}
CleanupStack::PopAndDestroy( &archives );
CleanupStack::PopAndDestroy( params );
}
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 CDTSYLogger::WriteRecord(const TDesC8& aText)
{
if(iValid)
{
TBuf8<KGenericBufferSize> buf;
TTime now;
now.UniversalTime();
TDateTime dateTime;
dateTime = now.DateTime();
buf.Format(_L8 ("%04d/%02d/%02d %02d.%02d:%02d:%06d "),dateTime.Year(),dateTime.Month()+1, dateTime.Day()+1,dateTime.Hour(),dateTime.Minute(),dateTime.Second(),dateTime.MicroSecond());
buf.AppendFormat(_L8("%S\015\012"),&aText);
iFile.Write(buf);
iFile.Flush();
}
}
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();
}
void CMemSpyEngineSinkMetaData::ConstructL( const TDesC& aRoot, const TDesC& aContext, const TDesC& aFolder, const TDesC& aExtension, const TTime& aFolderTime )
{
iRoot = aRoot.AllocL();
iContext = aContext.AllocL();
iFolder = aFolder.AllocL();
iExtension = aExtension.AllocL();
const TDateTime dt = aFolderTime.DateTime();
HBufC* spec = HBufC::NewLC( KMaxFileName );
TPtr pName( spec->Des() );
pName.Format( KMemSpyDataStreamFolderNameFormatSpec, dt.Year(), dt.Month()+1, dt.Day()+1, dt.Hour(), dt.Minute(), dt.Second());
iFolderTimeStamp = pName.AllocL();
CleanupStack::PopAndDestroy( spec );
}
// ---------------------------------------------------------------------------
// 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");
}
EXPORT_C void CMemSpyEngineOutputSink::DataStreamTimeStampBeginL( const TTime& aTime )
{
const TDateTime dt( aTime.DateTime() );
// Build it up...
HBufC* spec = HBufC::NewL( KMaxFileName );
TPtr pName( spec->Des() );
pName.Format( KMemSpyDataStreamFolderNameFormatSpec, dt.Year(), dt.Month()+1, dt.Day()+1, dt.Hour(), dt.Minute(), dt.Second());
DataStreamTimeStampEnd();
iDataStreamTimeStampSpecifier = spec;
}
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());
}
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);
}
// 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());
}
