TVerdict CTestVclntRepeat::DoTestL(CVideoPlayerUtility* aPlayer)
{
TVerdict ret = EFail;
INFO_PRINTF1(_L("Test : Video Player - Repeats"));
TInt duration = I64INT(aPlayer->DurationL().Int64());
// SetRepeats() doesn't exist in the video controller, so set iRepeat to 1
iRepeat = 1;
INFO_PRINTF1(_L("Warning : SetRepeats() does not exist in player API. Repeat count set to 1"));
aPlayer->Play();
INFO_PRINTF1(_L("CVideoPlayerUtility: Playing"));
TTime start;
start.HomeTime();
CActiveScheduler::Start();
TTime stop;
stop.HomeTime();
TUint actualDuration = I64INT(stop.MicroSecondsFrom(start).Int64());
INFO_PRINTF6(_L("Error : %d Start = %d Stop = %d Duration = %d ActualDuration = %d"),
iError, I64INT(start.Int64()), I64INT(stop.Int64()), duration, actualDuration);
if((iError == KErrNone) && (TimeComparison(actualDuration, duration * (iRepeat + 1),
KExpectedDeviation * iRepeat)))
ret = EPass;
return ret;
}
EXPORT_C TBool TWsGraphicMsgAnimation::IsPlaying(const TTime& aNow,const TTimeIntervalMicroSeconds& aAnimationLength) const
{
// an animation to time?
if(aAnimationLength <= 0LL)
{
return EFalse;
}
switch(iFlags & EStateMask)
{
case EPaused:
return EFalse;
case EStopping:
{
const TInt64 elapsed = (aNow.Int64() - iPlay.Int64());
if(elapsed <= aAnimationLength.Int64())
{
return ETrue;
}
return EFalse;
}
case EStopped:
return EFalse;
case EPlaying:
{
const TInt64 elapsed = (aNow.Int64() - iPlay.Int64());
if((iFlags & ELoop) || (elapsed <= aAnimationLength.Int64()))
{
return ETrue;
}
return EFalse;
}
default:
return EFalse;
}
}
/**
Tests UpdateVisited() API
@internalTechnology
@test
@param Reference to handle to the bookmark that is under test
@return None
*/
void CTestUpdateVisitedStep::DoTest(RBkBookmark& aBookmark)
{
const TInt KOneSecond = 1000000;
TTime initialTime;
// Set the time to universal time
initialTime.UniversalTime();
INFO_PRINTF2(_L("Current time before updating = %Ld"), initialTime.Int64());
INFO_PRINTF1(_L("Updating LastVisited..."));
// Call updatevisited after one second
User::After(KOneSecond);
aBookmark.UpdateVisited();
TTime lastVisitedTime = aBookmark.LastVisited();
INFO_PRINTF2(_L("LastVisitedTime after updating = %Ld"), lastVisitedTime.Int64());
// Check whether last visited is greater than the initial time
if(lastVisitedTime <= initialTime)
{
INFO_PRINTF1(_L("LastVisited was not updated properly"));
SetTestStepResult(EFail);
}
else
{
INFO_PRINTF1(_L("LastVisited was updated properly"));
}
} // DoTest
TVerdict CTestVclntDuration::DoTestL(CVideoPlayerUtility* aPlayer)
{
TVerdict ret = EFail;
INFO_PRINTF1(_L("Test : Video Player - Duration"));
if (I64INT(iDuration.Int64()) == 0)
{
TInt duration = I64INT(aPlayer->DurationL().Int64());
aPlayer->Play();
INFO_PRINTF1(_L("CVideoPlayerUtility: Playing"));
TTime start;
start.HomeTime();
CActiveScheduler::Start();
TTime stop;
stop.HomeTime();
TUint actualDuration = I64INT(stop.MicroSecondsFrom(start).Int64());
INFO_PRINTF6(_L("Error : %d Start = %d Stop = %d Duration = %d ActualDuration = %d"),
iError, I64INT(start.Int64()), I64INT(stop.Int64()), duration, actualDuration);
if((iError == KErrNone) && (TimeComparison(actualDuration, duration, KExpectedDeviation)))
ret = EPass;
}
else
{
if(aPlayer->DurationL() == iDuration)
ret = EPass;
}
return ret;
}
//Returns approximate difference (rounded down?) in seconds
EXPORT_C TInt CSchSendTestUtils::DiffInSecs(TTime d1, TTime d2)
{
iRTest<<d1<<d2;
TInt64 diffUs64 = d1.Int64() - d2.Int64();
TInt64 diffSecs64 = diffUs64 / (1000000);
TInt diffSecs32 = I64INT(diffSecs64);
return diffSecs32;
}
// --------------------------------------------------------------------------------------
// Generates random CID
// --------------------------------------------------------------------------------------
//
void CXmlEngSerializerXOP::GenerateRandomCid(TDes8& aCid)
{
_LIT8(KAt, "@");
//generate random CID as <randomNumber>@<homeTime>
TTime now;
now.HomeTime();
TInt64 homeTime = now.Int64();
TUint32 randomNumber = Math::Random();
aCid.AppendNum(randomNumber);
aCid.Append(KAt);
aCid.AppendNum(now.Int64());
}
// -----------------------------------------------------------------------------
// CSTSCredentialManager::CheckSearchResultsL
// Check key search results, generate CSR
// -----------------------------------------------------------------------------
void CSTSCredentialManager::CheckSearchResultsL()
{
// we take the first key with valid dates
TInt keyCount = iKeyInfoArray->Count();
CCTKeyInfo* keyInfo = NULL;
TTime timeNow;
timeNow.UniversalTime();
TBool found = EFalse;
TInt keyIndex = 0;
for (TInt i = 0; (i < keyCount) && (!found); i++)
{
keyInfo = iKeyInfoArray->operator[](i);
TTime startDate = keyInfo->StartDate();
if ((startDate.Int64() == 0) || (timeNow >= startDate))
{
// startDate was not set or is before current time
// exactly same time is valid as well
TTime endDate = keyInfo->EndDate();
if ((endDate.Int64() == 0) || (timeNow < endDate))
{
// endDate was not set or is after current time
// exactly same time is not valid
// (the key expires immediatelly)
if (keyInfo->Size() == iKeyLen)
{
// key must have same size
found = ETrue;
keyIndex = i;
}
}
}
}
if (!found)
{
Complete(KSTSErrSeNoKeys);
return;
}
if (iKeyInfo)
{
iKeyInfo->Release();
}
iKeyInfo = keyInfo;
// iKeyInfo is no longer owned by iKeyInfoArray
iKeyInfoArray->Remove(keyIndex);
CSRDialog();
}
void CSyncEngineWrap::ConstructL()
{
//create suspended thread
_LIT(KThreadName, "SyncThreadEntryPoint");
TBuf<30> threadName;
threadName.Append(KThreadName);
TTime time;
time.HomeTime();
TInt64 aSeed = time.Int64();
TInt randNum = Math::Rand(aSeed) % 1000;
threadName.AppendNum(randNum);
//KMinHeapSize, 256*KMinHeapSize
//TInt res = thread.Create(threadName, SyncThreadEntryPoint, 20000, 0x100000, 0x3D4000, this);
TInt res = thread.Create(threadName, SyncThreadEntryPoint, 20000, 0x5000,
0x600000, this);
if (res != KErrNone)
Panic(ERhodesSyncEngineInit);
thread.SetPriority(EPriorityNormal);
}
TVpnPolicyId CPolicyStore::NewPolicyIdL()
{
TUuid uuid;
TUuidString uuidString;
Uuid::MakeUuidL(uuid);
// It has become apparent that certain
// Symbian OS devices generate duplicate random
// number sequences after gold boot due to improper
// seeding of the random number generator. Should
// this happen to be the case, we insert at least
// one component to the UUID that depends on the
// current system time. This is not perfect, but
// should give us policy IDs that are unique enough.
TTime now;
now.UniversalTime();
TInt64 randSeed = now.Int64();
TInt randomNum = Math::Rand(randSeed);
uuid.iTimeLow = static_cast<TUint32>(randomNum);
Uuid::UuidToString(uuid, uuidString);
TVpnPolicyId newPolicyId;
newPolicyId.Copy(uuidString);
return newPolicyId;
}
LOCAL_C void baseRomImage()
//
// Set base addresses for the ROM image.
//
{
test.Start(_L("Setting up the header"));
Mem::FillZ(&TheRomHeader,sizeof(TRomHeader));
test.Printf(_L("1"));
TheRomHeader.iVersion=TVersion(1,0,1);
test.Printf(_L("2"));
TTime t;
t.HomeTime();
test.Printf(_L("3"));
TheRomHeader.iTime=t.Int64();
test.Printf(_L("4"));
TheRomHeader.iRomBase=UserSvr::RomHeaderAddress();
test.Printf(_L("5"));
TheRomHeader.iRomRootDirectoryList=TheCurrentBase=UserSvr::RomHeaderAddress()+sizeof(TRomHeader);
test.Printf(_L("6"));
//
test.Next(_L("Set dirs base"));
TheRootDir->SetBaseDirs();
//
test.Next(_L("Set files base"));
TheRootDir->SetBaseFiles();
TheRomHeader.iRomSize=TheCurrentBase-UserSvr::RomHeaderAddress();
//
test.End();
}
double currentTime()
{
TTime current;
current.HomeTime();
// second resolution instead of microsecond
return I64REAL( current.Int64() ) / 1000000;
}
EXPORT_C CWatcherBase::CWatcherBase(TInt aPriority)
: CActive(aPriority)
{
CActiveScheduler::Add(this);
#ifdef WATCHER_TESTING
//-- this section of code is used by TE_TelWatchers(Unit) test
TTime now;
now.UniversalTime();
TheSeed = now.Int64();
//-- define properties for test purposes
OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CWATCHERBASE_CTOR_1, "CTelWatcherBase : defining properties for testing");
//-- For debugging purposes only, used by TE_TelWatchers(Unit).
//- this property change (to any value) informs that CTelPhoneWatcher has re-read modem table from commdb in
//- CTelPhoneWatcher::DoRetrieveTSYNameL().
RProperty::Define(KUidSystemCategory, KUidTestProp_ModemTableRefreshed.iUid, RProperty::EInt);
//- this property changes in CTelPhoneWatcher::HandleModemChangedL()
//- when the commsdb modem record has changed
RProperty::Define(KUidSystemCategory, KUidTestProp_ModemRecordChanged.iUid, RProperty::EInt);
//-- this property is used in CIndicatorWatcher::HandleIndicatorUpdateL()
//-- to simulate call state change by t_watchers test
RProperty::Define(KUidSystemCategory, KUidTestProp_CallStateChange.iUid, RProperty::EInt);
//-- this property is used to disable and reset phone watchers
RProperty::Define(KUidSystemCategory, KUidTestProp_WatchersDisable.iUid, RProperty::EInt);
#endif
}
CTestAppUi::CTestAppUi()
: iRandSeed(KRandSeed)
{
TTime time;
time.HomeTime();
iRandSeed=time.Int64();
}
// MceSip::Random
// -----------------------------------------------------------------------------
//
TUint MceSip::Random( TUint aMinValue, TUint aMaxValue )
{
TUint randomValue( aMinValue <= aMaxValue ? aMinValue : 0 );
if ( aMinValue <= aMaxValue )
{
TTime time;
time.HomeTime();
TInt64 seed( time.Int64() );
for ( TUint i = 0; i < ( aMaxValue - aMinValue ); i++ )
{
TInt random = Math::Rand( seed );
TReal random2 = ( TReal )random / KMceRandDividerOne;
TUint random3 = ( TUint )( aMaxValue * random2 ) /
KMceRandDividerTwo;
if ( aMinValue <= random3 && aMaxValue >= random3 )
{
randomValue = random3;
break;
}
}
}
return randomValue;
}
// ---------------------------------------------------------
// CT_LbsInstallPsyTp273::NotifyPositionUpdate
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CT_LbsInstallPsyTp273::NotifyPositionUpdate(
TPositionInfoBase& aPosInfo,
TRequestStatus& aStatus)
{
TInt err = KErrNone;
TTime tt;
tt.UniversalTime();
//Request ID must be unique, use universalime as seed
// to give a random number
TInt64 seed = tt.Int64();
TReal lat = 90 * Math::FRand(seed);
TReal lon = 90 * Math::FRand(seed);
TReal32 alt = (TReal32)(90 * Math::FRand(seed));
TPositionInfo* position = static_cast<TPositionInfo*> (&aPosInfo);
TUid implUid = { KPosImplementationUid };
position->SetModuleId(implUid);
TTime now;
now.UniversalTime();
TPosition posse;
posse.SetCoordinate(lat, lon, alt);
posse.SetTime(now);
position->SetPosition(posse);
TRequestStatus* status = &aStatus;
User::RequestComplete(status, err);
}
// -----------------------------------------------------------------------------
// CTFTestCaseRepeater::RunTestL
// -----------------------------------------------------------------------------
void CTFTestCaseRepeater::RunTestL( void )
{
COMPONENT_TRACE( ( _L( " DSYTESTTOOL - CTFTestCaseRepeater::RunTestL()" ) ) );
if ( iSuite != NULL )
{
RHeap& heap = User::Heap();
TInt heapSizeStart = 0;
TInt heapCountStart = 0;
TInt err;
heapCountStart = heap.AllocSize( heapSizeStart );
if ( iRandomRepeat )
{
TTime time;
time.HomeTime();
TInt64 seed = time.Int64();
for ( TInt i = 0; i < iRepeatCount; i++ )
{
TInt index = Math::Rand( seed ) % iSuite->Count();
CTFATest& test = iSuite->At( index );
// The test suites and repeater test cases are not run
if ( test.Type() != ETFTestTypeStubRepeater && test.Type() != ETFATestTypeSuite )
{
STATIC_CAST( CTFATestCase*, &test )->SetupL();
TRAP( err, STATIC_CAST( CTFATestCase*, &test )->RunTestL() );
STATIC_CAST( CTFATestCase*, &test )->Teardown();
User::LeaveIfError( err );
}
else
{
i--;
}
}
CRandomBlobStep::CRandomBlobStep() : CPerformanceFunctionalityBase( KNumberOfContacts )
{
SetTestStepName(KRandomBlobStep);
TTime time;
time.UniversalTime();
iSeed = time.Int64();
}
OrganizerItemGuidTransform::OrganizerItemGuidTransform()
{
// Set seed for qrand()
TTime homeTime;
homeTime.HomeTime();
uint seed = (uint) homeTime.Int64();
qsrand(seed);
}
CDnsSocketWriter::CDnsSocketWriter(CDnsSocket &aMaster) : CActive(0), iMaster(aMaster)
{
LOG(Log::Printf(_L("CDnsSocketWriter[%u]::CDnsSocketWriter([%u])"), this, &aMaster));
CActiveScheduler::Add(this);
TTime seed;
seed.UniversalTime();
iSequence = seed.Int64();
}
void FillRandomData(TDes& aData)
{
// get random seed
TTime time;
time.UniversalTime();
TInt64 seed = time.Int64();
// do the filling
FillRandomData(aData, seed);
}
CTestAppUi::CTestAppUi()
: iRandSeed(KRandSeed),
iDoKills(EFalse),
iIsServerEventTimeOutEnabled(ETrue)
{
TTime time;
time.HomeTime();
iRandSeed=time.Int64();
}
TInt CCommonUtils::Rand(TInt aMax,TInt aMin)
{
TTime now;
now.HomeTime();
TInt64 iSeed = now.Int64();
TInt random = (Math::Rand(iSeed) % aMax) + aMin;
return random;
}
void get_random_seed(void **randseed, int *randseedsize) {
TInt64 *now = snew(TInt64);
TTime time;
time.UniversalTime();
*now = time.Int64();
*randseed = now;
*randseedsize = sizeof(now);
}
// ---------------------------------------------------------------------------
// CTransactionIDGenerator::CTransactionIDGenerator
// ---------------------------------------------------------------------------
//
CTransactionIDGenerator::CTransactionIDGenerator()
{
TUint ticks = User::TickCount();
TTime now;
now.UniversalTime();
TInt64 us = now.Int64();
iSeed = static_cast<TInt64>( ticks ) + us;
iCounter = I64LOW( us ) - ticks;
}
/*
** Find the current time (in Universal Coordinated Time). Write the
** current time and date as a Julian Day number into *prNow and
** return 0. Return 1 if the time and date cannot be found.
*/
int symTime(
sqlite3_vfs* /*pVfs*/,
double* prNow )
{
TTime now;
now.UniversalTime();
*(TInt64*)prNow = now.Int64();
return 0;
}
void DoInserts(TInt aProcId, TInt aRecId1, TInt aRecId2)
{
TEST(TheDb != 0);
TTime now;
now.UniversalTime();
TInt64 seed = now.Int64();
const TInt KMaxFailingAllocationNo = 20;
TInt lockcnt = 0;
for(TInt recno=0;recno<KTestRecordCnt;)
{
//Insert record 1 under OOM simulation
TInt failingAllocationNo = Math::Rand(seed) % (KMaxFailingAllocationNo + 1);
__UHEAP_SETFAIL(RHeap::EDeterministic, failingAllocationNo );
TBuf8<100> sql;
sql.Format(_L8("INSERT INTO A VALUES(%d)"), aRecId1);
TInt err = sqlite3_exec(TheDb, (const char*)sql.PtrZ(), 0, 0, 0);
__UHEAP_SETFAIL(RHeap::ENone, 0);
TEST(err == SQLITE_NOMEM || err == SQLITE_BUSY || err == SQLITE_OK);
if(err == SQLITE_BUSY)
{
++lockcnt;
User::After(1);
continue;
}
else if(err == SQLITE_OK)
{
++recno;
if((recno % 100) == 0)
{
RDebug::Print(_L("Process %d: %d records inserted.\r\n"), aProcId, recno);
}
continue;
}
//Insert record 2
sql.Format(_L8("INSERT INTO A VALUES(%d)"), aRecId2);
err = sqlite3_exec(TheDb, (const char*)sql.PtrZ(), 0, 0, 0);
TEST(err == SQLITE_BUSY || err == SQLITE_OK);
if(err == SQLITE_BUSY)
{
++lockcnt;
User::After(1);
continue;
}
//SQLITE_OK case
++recno;
if((recno % 100) == 0)
{
RDebug::Print(_L("Process %d: %d records inserted.\r\n"), aProcId, recno);
}
}
RDebug::Print(_L("Process %d inserted %d records. %d locks occured.\r\n"), aProcId, KTestRecordCnt, lockcnt);
}
// -----------------------------------------------------------------------------
// CBTGPSRequestManager::HandleMessage
// -----------------------------------------------------------------------------
void CBTGPSRequestManager::HandleMessage(const TBTGPSNmeaParser& aParser)
{
//Add the received message to buffer
iNmeaBuffer->AddSentences(aParser.NmeaSentence());
//Add 0x0d 0x0a
iNmeaBuffer->AddSentences(KBTGPSNmeaTerminator);
//Parse the message
CBTGPSFix::TParsingStatus err = iFix->ParseMessage(aParser);
//Check if we have received a valid sentence
if(err == CBTGPSFix::EInfoUpdated)
{
if(iFix->IfFullNmeaPatternReceived())
{
TTime gsvTime = iFix->GsvTime();
TTime now;
now.UniversalTime();
TRACESTRING2("CBTGPSRequestManager:: Now time = %d", now.Int64())
TRACESTRING2("CBTGPSRequestManager:: GSV time = %d", gsvTime.Int64())
if(gsvTime!=0 && now.MicroSecondsFrom(gsvTime)<
CBTGPSRequestHandler::ConstantsManager().iSatelliteInfoLifeTime)
{
//GSV information is still valid, set fix as valid
TRACESTRING("CBTGPSRequestManager:: GSV information is still valid")
iTimer->Cancel();
InformListeners();
}
else
{
if(!iTimer->IsActive())
{
//GSV information is not valid, start timer
iTimer->Start(
KBTGPSGsvWaitTime,
KBTGPSGsvWaitTime,
TCallBack(TimerCallback, this));
}
}
}
}
// ----------------------------------------------------------------------------
// Constructor
// ----------------------------------------------------------------------------
//
CSipSecIpsecMechanism::CSipSecIpsecMechanism(
TSIPSecMechanismInitParams* aInitParams ) :
iTimerMgr( aInitParams->iTimer ),
iEngineContext( aInitParams->iEngineContext ),
iTransportMgr( aInitParams->iTransportMgr ),
iT1( aInitParams->iT1 ),
iStates( KStatesGranularity )
{
TTime time;
time.HomeTime();
iSeed = time.Int64();
}
// -----------------------------------------------------------------------------
// CTransactionIDGenerator::AddClockInfo
// -----------------------------------------------------------------------------
//
void CTransactionIDGenerator::AddClockInfo( TDes8& aBuf ) const
{
TTime now;
now.UniversalTime();
TInt64 timeAsInt = now.Int64();
aBuf.Append( reinterpret_cast<const TUint8*>( &timeAsInt ),
sizeof( timeAsInt ) );
TUint ticks = User::TickCount();
aBuf.Append( reinterpret_cast<const TUint8*>( &ticks ), sizeof( ticks ) );
}
TStsTransactionId CStsServer::CreateTransactionID()
{
TTime currentTime;
TStsTransactionId transactionID;
do
{
currentTime.UniversalTime();
transactionID = I64LOW(currentTime.Int64());
}
while(IsExistingTransaction(transactionID));
return transactionID;
}
