/**
@SYMTestCaseID SYSLIB-BAFL-CT-0435
@SYMTestCaseDesc Tests for TResourceReader::ReadInt16(),TResourceReader::ReadInt64() function
@SYMTestPriority High
@SYMTestActions Attempt for reading FLPTED resource
@SYMTestExpectedResults Tests must not fail
@SYMREQ REQ0000
*/
void TRsReadTester::TestFlPtEdL()
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0435 Test reading FLPTED resource "));
TResourceReader reader;
CreateResourceReaderLC(reader,SYS_FLPTED_ONE);
test(reader.ReadInt16()==18);
TReal little=reader.ReadReal64();
test(little==0.0);
TReal big=reader.ReadReal64();
test(big>9.89e99);
test(big<9.91e99);
CleanupStack::PopAndDestroy(1);
}
TBool CSuspendTest::ValidateBlock( TInt aBlockNumber, TUint32 aFillWord )
//
// Checks that every word in block aBlockNumber has the value aFillWord
//
{
TUint offset = aBlockNumber * iBlockSize;
test.Printf( _L("Validating block %d (offs=0x%x)\n"), aBlockNumber, offset );
TBool failed = EFalse;
const TInt readBufLen = iReadBuffer.MaxLength();
for( TInt len = iBlockSize; len > 0 && !failed ;)
{
TInt r = iDrive.Read( offset, readBufLen, iReadBuffer );
if( r != KErrNone )
{
test.Printf( _L("... FAIL: read failed (%d) at offset 0x%x\n"), r, offset );
test( KErrNone == r );
}
test( iReadBuffer.Length() == readBufLen );
TUint32* p = (TUint32*)iReadBuffer.Ptr();
for( TInt i = 0; i < readBufLen; i += 4 )
{
if( aFillWord != *p )
{
failed = ETrue;
test.Printf( _L("... FAILED: word @ offs=0x%x, read=0x%x, expected=0x%x\n"),
offset+i, p[0], aFillWord );
break;
}
++p;
}
offset += readBufLen;
len -= readBufLen;
}
return !failed;
}
TInt E32Main()
{
__UHEAP_MARK;
test.Title();
test.Start(_L("initialising"));
CTrapCleanup* c=CTrapCleanup::New();
// start the loader
RFs fs;
test (fs.Connect()==KErrNone);
fs.Close();
test (c!=0);
TRAPD(r,MainL());
test (r==KErrNone);
delete c;
test.End();
test.Close();
__UHEAP_MARKEND;
return KErrNone;
}
/**
@SYMTestCaseID PDS-DBMS-UT-4009
@SYMTestCaseDesc DBMS performance tests.
@SYMTestPriority High
@SYMTestActions The test opens the test database and:
- selects the ids of the tracks to be deleted and collects them into an array;
- deletes the recods with matching track ids from TRACK table;
- deletes the recods with matching track ids from TRACK2 table;
The execution times are printed out.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ7141
*/
void DeleteTracksL()
{
TheTest.Printf(_L("Record count: %d\r\n"), KTrackRecordCount);
RArray<TInt> tracks;
tracks.ReserveL(KTrackRecordCount);
CleanupClosePushL(tracks);
SelectTracksL(KTrackRecordCount, tracks);
//
_LIT(KDeleteSql, "DELETE FROM tracks WHERE id>=%d AND id<=%d");
TBuf<100> sql;
sql.Format(KDeleteSql, tracks[0], tracks[tracks.Count() - 1]);
TUint32 fc2 = User::FastCounter();
TInt err = TheDatabase.Begin();
TEST2(err, KErrNone);
TUint32 fc = User::FastCounter();
TInt rc = TheDatabase.Execute(sql);
PrintFcDiffAsUs(_L("###\"DELETE FROM TRACKS\",time=%d us\r\n"), CalcTickDiff(fc, User::FastCounter()));
TEST2(rc, KTrackRecordCount);
TheTest.Printf(_L("Deleted record count: %d\r\n"), rc);
sql.Replace(12, 6, _L("TRACKS2"));
fc = User::FastCounter();
rc = TheDatabase.Execute(sql);
PrintFcDiffAsUs(_L("###\"DELETE FROM TRACKS2\",time=%d us\r\n"), CalcTickDiff(fc, User::FastCounter()));
TEST2(rc, KTrackRecordCount);
TheTest.Printf(_L("Deleted record count: %d\r\n"), rc);
err = TheDatabase.Commit();
TEST2(err, KErrNone);
PrintFcDiffAsUs(_L("###Total \"DELETE FROM TRACKS\",time=%d us\r\n"), CalcTickDiff(fc2, User::FastCounter()));
CleanupStack::PopAndDestroy(&tracks);
}
static void TestFileSeek()
//
// Benchmark file seek method
//
{
ClearSessionDirectory();
test.Next(_L("RFile::Seek method"));
TInt increment=1789; // random number > cluster size
TInt count=0;
TInt pos=0;
// Create test file
TBuf8<1024> testdata(1024);
RFile f;
TInt r=f.Create(TheFs,_L("SEEKTEST"),EFileStream);
test_KErrNone(r);
count=64;
while (count--)
f.Write(testdata);
TInt fileSize=count*testdata.MaxLength();
pos=0;
count=0;
RTimer timer;
timer.CreateLocal();
TRequestStatus reqStat;
timer.After(reqStat,10000000); // After 10 secs
while(reqStat==KRequestPending)
{
TInt dum=(pos+=increment)%fileSize;
f.Seek(ESeekStart,dum);
count++;
}
test.Printf(_L("RFile::Seek operations in 10 secs == %d\n"),count);
timer.Close();
f.Close();
TheFs.Delete(_L("SEEKTEST"));
}
void TTestCase::SelfTest()
{
test.Start(_L("Unit test of TTestCase::TestCaseValid\n"));
// Create a TTestCase with paramaters CAP1 and CAP2
// call TTestCase::TestCaseValid against CAPSET
// Expected result is EXPCT
#define TEST_TEST_CASE(CAP1, CAP2, CAPSET, EXPCT)\
{\
test.Next(_L(#CAP1 L", " L ## #CAP2 L" -- Against: " L ## #CAPSET L", Expect: " L ## #EXPCT));\
TTestCase testCase(NULL, EFalse, CAP1, CAP2);\
testCase.iChannelCaps[0] = (CAP1);\
TResult t = testCase.TestCaseValid(CAPSET);\
test_Equal(EXPCT, t);\
}
TEST_TEST_CASE(pauseRequired, hwDesNotWanted, KTestCapSet, EFail);
TEST_TEST_CASE(pauseRequired_skip, hwDesNotWanted, KTestCapSet, EFail);
TEST_TEST_CASE(pauseRequired_skip, hwDesNotWanted_skip, KTestCapSet, ESkip);
TEST_TEST_CASE(pauseNotWanted, hwDesNotWanted_skip, KTestCapSet, ESkip);
TEST_TEST_CASE(pauseNotWanted, hwDesWanted, KTestCapSet, ERun);
TEST_TEST_CASE(pauseNotWanted, none, KTestCapSet, ERun);
TEST_TEST_CASE(pauseNotWanted, capAboveV1, KDmacTestCapsV1, ESkip);
TEST_TEST_CASE(pauseNotWanted, capAboveV1, KDmacTestCapsV2, ERun);
TEST_TEST_CASE(pauseNotWanted, capBelowV2, KDmacTestCapsV1, ERun);
TEST_TEST_CASE(pauseNotWanted, capBelowV2, KDmacTestCapsV2, ESkip);
// contradictory requirements
TEST_TEST_CASE(capAboveV1, capBelowV2, KDmacTestCapsV2, ESkip);
TEST_TEST_CASE(capBelowV2, capAboveV1, KDmacTestCapsV2, ESkip);
TEST_TEST_CASE(capAboveV1, capBelowV2, KDmacTestCapsV1, ESkip);
TEST_TEST_CASE(capBelowV2, capAboveV1, KDmacTestCapsV1, ESkip);
test.End();
test.Close();
}
/**
Run check buffers on the supplied TAddressParms array
*/
TBool DoTferParmTestL(const TAddressParms* aParms, TInt aCount, TBool aAllowRepeat, TBool aPositive)
{
_LIT(KPositive, "positive");
_LIT(KNegative, "negative");
test.Printf(_L("CheckBuffers %S test: %d args, repeats allowed %d\n"),
(aPositive ? &KPositive : &KNegative), aCount, aAllowRepeat);
RArray<const TAddressParms> array;
ArrayAppendL(array, aParms, aParms + aCount);
TPreTransferIncrBytes preTran;
TBool r = preTran.CheckBuffers(array, aAllowRepeat);
array.Close();
return r;
}
GLDEF_C TInt E32Main()
{
__UHEAP_MARK;
TheTest.Printf(_L("\n"));
TheTest.Title();
TheTest.Start(_L("ServerStartupMgr Tests."));
TEST2(TheFs.Connect(), KErrNone);
// get clean-up stack
CTrapCleanup* cleanup = CTrapCleanup::New();
// Construct and install the Active Scheduler. The Active Scheduler is needed
// by components used by this test as they are ActiveObjects.
CActiveScheduler* activeScheduler = new(ELeave)CActiveScheduler;
CActiveScheduler::Install(activeScheduler);
EnableEcomTestBehaviour(TheTest, TheFs);
TRAPD(err,DoTestsL());
ResetSsa(TheTest, TheFs);
TheTest(err==KErrNone);
DisableEcomTestBehaviour(TheTest, TheFs);
TheTest.End();
TheTest.Close();
//delete scheduler;
delete activeScheduler;
delete cleanup;
TheFs.Close();
__UHEAP_MARKEND;
User::Heap().Check();
return KErrNone;
}
static void TestDeleteKey()
/**
Test deleting keys with the session. See in-function comments
for specific test cases.
*/
{
test.Start(_L("TestDeleteKey"));
// IMPORT_C TInt DeleteKey(TKeyHandle aHandle);
TInt r;
// success case - known key
r = kms.DeleteKey(GenHandle0);
test(r == KErrNone);
// failure case - key not known
r = kms.DeleteKey(GenHandle0);
test(r == KErrNotFound);
test.End();
}
TInt E32Main()
{
__UHEAP_MARK;
CTrapCleanup* tc = CTrapCleanup::New();
TEST(tc != NULL);
TheTest.Title();
TRAPD(err, ::MainL());
TEST2(err, KErrNone);
TheTest.End();
TheTest.Close();
delete tc;
CloseSTDLIB();
__UHEAP_MARKEND;
User::Heap().Check();
return KErrNone;
}
// Manual test - requires user to move a card between two physical slots
extern TInt E32Main()
{
test.Start(_L("T_MULTISLOT Test"));
test(fs.Connect()==KErrNone);
// Get the list of removable drive driver-letters
TDriveList driveList;
test(fs.DriveList(driveList,KDriveAttRemovable)==KErrNone);
TInt length=driveList.Length();
TBool pass = EFalse;
// i is drive letter (as int)
// for every removable media logical drive
for(TInt i=0; i<length; i++)
{
if(driveList[i] == 0)
{
continue;
}
TChar driveChar = i+'A';
test.Next(_L("Testing Logical Drive"));
TInt FirstlocDrvNum = KErrNotFound;
TInt SecondlocDrvNum = KErrNotFound;
TInt driveNum = -1;
driveNum = i+'A';
test.Printf(_L("Logical Drive : %d"), driveNum);
// Get local drive number by gettin ghr Serial number fo the card (RFs call), then
// enumerating the TBusLocalDrives and finding one that matches.
test(FindMmcLocalDriveNumber(driveChar,FirstlocDrvNum,driveNum)==KErrNone);
// Got first local drive number, now move card into second slot.
test.Printf(_L("<Move MMC Card to second slot, then press any key>"));
test.Getch();
// Get second local drive number for same logical drive (should be different local drive number).
test(FindMmcLocalDriveNumber(driveChar,SecondlocDrvNum,driveNum)==KErrNone);
if(FirstlocDrvNum!=SecondlocDrvNum)
{
pass=ETrue;
break;
}
// else perhaps this wasn't a multislot drive
}
test(pass);
test.End();
test.Close();
fs.Close();
return KErrNone;
}
LOCAL_C void TestUpdatedLocalizationFilesL()
{
TInt originalNumCities = GetNumCitiesFromGroupL(KDefaultCityGroupId);
test.Printf(_L(" @SYMTestCaseID PIM-APPSERV-TZLOC-TZL-ECL-0001 "));
test.Printf(_L("The number of cities found in a city group in the default files are %d\n"), originalNumCities);
//Install a patch with new localization files on the c: drive
TRequestStatus reqStatus;
CCTzSwiPluginTester* sisInstaller = CCTzSwiPluginTester::NewLC();
sisInstaller->InstallSIS(KFlashLocalizationUpgradeSis(), CCTzSwiPluginTester::EPropertyNames, reqStatus);
CActiveScheduler::Start();
//Get the new number of cities from the group, this should come from the eclipsed files
TInt flashNumCities = GetNumCitiesFromGroupL(KDefaultCityGroupId);
test.Printf(_L("The number of cities found in a city group in the new installed files are %d\n"), flashNumCities);
test(originalNumCities < flashNumCities);
test (sisInstaller->UninstallSIS(KTimeZonePackageUid(), KTimeZonePackageName(), KTimeZoneVendorName()) == KErrNone);
//Need this to allow the notification plug-in code to run
User::After(1000000);
CleanupStack::PopAndDestroy(sisInstaller);
TInt romNumCities = GetNumCitiesFromGroupL(KDefaultCityGroupId);
test.Printf(_L("The number of cities found in a city group in the rom files are %d\n"), romNumCities);
test(originalNumCities == romNumCities);
}
TInt E32Main()
{
TheTest.Title();
CTrapCleanup* tc = CTrapCleanup::New();
TheTest(tc != NULL);
__UHEAP_MARK;
DoTests();
DeleteTestFiles();
__UHEAP_MARKEND;
TheTest.End();
TheTest.Close();
delete tc;
User::Heap().Check();
return KErrNone;
}
void CDummyCalendarApp::RepeatExceptedEntryCreateL()
{
test.Next(_L("Add entry, repeat twice, set excepted and delete"));
iEntries.ResetAndDestroy();
// Create new calendar entry.
CCalEntry* entry = NULL;
HBufC8* guid = KGUIDInc081869().AllocLC();
entry = CreateCalEntryL(CCalEntry::EAppt, guid);
CleanupStack::Pop(guid);
iEntries.AppendL(entry);
// Set start and end date.
TTime start(TDateTime(2006, EMarch, 6, 10, 0, 0, 0));
TTime end(TDateTime(2006, EMarch, 6, 14, 0, 0, 0));
SetEntryStartAndEndTimeL(entry, start, end);
TBuf<50> summary;
RandomText(summary);
entry->SetSummaryL(summary);
TBuf<50> location;
RandomText(location);
entry->SetLocationL(location);
TBuf<50> description;
RandomText(description);
entry->SetDescriptionL(description);
// Create a daily repeating rule that occurs for 2 days.
TCalRRule rpt(TCalRRule::EDaily);
rpt.SetInterval(1);
rpt.SetCount(2);
// Make sure the repeat time is within the delete time range.
TCalTime repeatStart;
TCalTime repeatEnd;
repeatStart.SetTimeLocalL(TDateTime(2006, EMarch, 6, 0, 0, 0, 0));
repeatEnd.SetTimeLocalL(TDateTime(2006, EMarch, 8, 0, 0, 0, 0));
rpt.SetDtStart(repeatStart);
rpt.SetUntil(repeatEnd);
entry->SetRRuleL(rpt);
// Store the entry. Because it repeats over 2 days, there will
// be 2 entries.
TInt entriesStored(0);
SynCGetEntryViewL().StoreL(iEntries, entriesStored);
test(entriesStored == iEntries.Count());
}
void CTestPerf::ReadComplete(TInt aStatus)
{
if (iTrace)
Test.Printf(_L("CTestPerf::ReadComplete(%d) len = %d/%d\r\n"), aStatus, iWriter->iDes.Length(), iWriter->iDes.MaxLength());
if (aStatus!=KErrNone)
{
Fail(ETestFailRead, aStatus);
return;
}
switch (iState)
{
case EWaitIO:
iRetries = 0;
iTimer->Cancel();
iCount += iReader->iCount;
iPackets++;
{
TTime end;
end.UniversalTime();
TInt64 difftime = (end.MicroSecondsFrom(iStartTime).Int64()+TInt64(500000))/TInt64(1000000);
if (difftime==0)
difftime = 1;
TInt64 cps = MAKE_TINT64(0,iCount)/difftime;
TInt rate = (I64INT(cps)*10000)/11520;
iRate += rate;
iSpeed += I64INT(cps);
Test.Printf(_L("%c %6d %d (%dbps=%d.%02d%%)\r"), KSpinner[iSpin++ & 3], iPackets, iCount, iSpeed/iPackets, (iRate/iPackets)/100, (iRate/iPackets)%100);
}
Read();
break;
default:
break;
}
}
void VfsCreateDeleteOnCloseFileOomTest()
{
sqlite3_vfs* vfs = sqlite3_vfs_find(NULL);
TEST(vfs != NULL);
sqlite3_file* osFile = (sqlite3_file*)User::Alloc(vfs->szOsFile);
TEST(osFile != NULL);
TheTest.Printf(_L("Iteration: "));
TInt failingAllocNum = 0;
TInt err = SQLITE_IOERR_NOMEM;
while(err == SQLITE_IOERR_NOMEM)
{
++failingAllocNum;
TheTest.Printf(_L("%d "), failingAllocNum);
OomPreStep(failingAllocNum);
int outFlags = 0;
err = sqlite3OsOpen(vfs, KTestFile4Z, osFile, SQLITE_OPEN_CREATE | SQLITE_OPEN_DELETEONCLOSE, &outFlags);
if(err == SQLITE_OK)
{
err = sqlite3OsClose(osFile);
}
OomPostStep();
if(err != SQLITE_OK)
{
TEST2(err, SQLITE_IOERR_NOMEM);
}
//Whether the iteration has failed or succeeded, the file should not exist.
TPtrC8 ptrname((const TUint8*)KTestFile4Z);
TBuf<50> fname;
fname.Copy(ptrname);
TInt err2 = TheFs.Delete(fname);
TEST2(err2, KErrNotFound);
}
TEST2(err, SQLITE_OK);
TheTest.Printf(_L("\r\n=== TVfs::Open(<delete on close file>) OOM test succeeded at allcoation %d\r\n"), failingAllocNum);
User::Free(osFile);
}
void TestExDriver::TestDevicePresent()
{
iTest.Next(_L("Testing Logical Device API"));
TInt r;
// RDevice is the user side handle of LDD factory object.
RDevice device;
iTest.Printf(_L("Open the Device\n"));
// Open the device with reference to the driver name.
r = device.Open(KDriverName);
if (r==KErrNone)
{
iTest.Printf(_L("Get Device Capabilities\n"));
// Package the device capabilities structure to a descriptor
// suitable to be passed to RDevice::GetCaps()
//
TPckgBuf<TCapsDevCommV01> caps;
// Get the device capabilities. Driver fills in the capabilities
// in caps and returns to user.
//
device.GetCaps(caps);
// Retrieve the information from caps and validate name and version
TVersion expectedVer(RExDriverChannel::VersionRequired());
iTest(caps().version.iMajor==expectedVer.iMajor);
iTest(caps().version.iMinor==expectedVer.iMinor);
iTest(caps().version.iBuild==expectedVer.iBuild);
iTest.Printf(_L("Close the device\n"));
// Close the device. This handle is required only to get any device
// related information from LDD factory object.
//
device.Close();
}
}
static void doMainL()
{
CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;
CleanupStack::PushL(scheduler);
CActiveScheduler::Install(scheduler);
CSqlSearcher* searcher = CSqlSearcher::NewLC();
HBufC* buff = HBufC::NewLC(1024);
TPtr ptr = buff->Des();
TheTest.Next(_L("A very short search string"));
ptr.Zero();
ptr.AppendFill(TChar('x'), 3);
searcher->DoSearchL(*buff, KUidContactFieldFamilyName);
TheTest.Next(_L("A fairly long search string"));
ptr.Zero();
ptr.AppendFill(TChar('x'), 233);
searcher->DoSearchL(*buff, KUidContactFieldFamilyName);
TheTest.Next(_L("A very slightly longer search string"));
ptr.Zero();
ptr.AppendFill(TChar('x'), 234);
searcher->DoSearchL(*buff, KUidContactFieldFamilyName);
TheTest.Next(_L("A very long search string"));
ptr.Zero();
ptr.AppendFill(TChar('x'), 600);
searcher->DoSearchL(*buff, KUidContactFieldFamilyName);
CleanupStack::PopAndDestroy(buff);
CleanupStack::PopAndDestroy(searcher);
CleanupStack::PopAndDestroy(scheduler);
}
// send a request and match a known response, show data only if a mismatch
TBool testSdpReqL(RTest& test, TUint8* aReqData, TUint aReqLen, TUint8 aReqId, TUint8* aRespData, TUint aRespLen, TUint8 aRespId, TUint aRespSize)
{
TUint8 pduId = aReqId;
TBool testMatch;
HBufC8* requestHBuf = HBufC8::New(aReqLen);
HBufC8* responseHBuf;
TPtr8 request = requestHBuf->Des();
request.SetLength(0);
request.Append(aReqData, aReqLen);
responseHBuf = InjectLC(pduId, request, aRespSize);
if (pduId == aRespId)
{
TInt respCmp = Mem::Compare(aRespData, aRespLen, &responseHBuf->Des()[0], responseHBuf->Length());
if (respCmp)
{
test.Printf(_L("no match at offset %d:\n"), respCmp);
HexDes(responseHBuf->Des());
test.Printf(_L("\n"));
testMatch = EFalse;
}
else
{
test.Printf(_L("Response OK\n"));
testMatch = ETrue;
}
}
else
{
test.Printf(_L("Error:"));
HexDes(responseHBuf->Des());
test.Printf(_L("\n"));
testMatch = EFalse;
}
CleanupStack::PopAndDestroy(/*responseHBuf*/);
delete requestHBuf;
return testMatch;
}
GLDEF_C TInt E32Main()
{
test.Title();
test.Start(_L("Create chunk"));
RChunk c;
TInt r=c.CreateDisconnectedLocal(0,0x1000,0x100000);
test(r==KErrNone);
r=c.Commit(0x10000,0x1000);
test(r==KErrNone);
TUint8* pBuf1=c.Base();
TUint8* pBuf2=pBuf1+0x10000;
TInt s;
TInt d;
TInt l;
for (l=1; l<300; l+=3)
{
for (s=0; s<=4096-l; s+=227)
{
test.Printf(_L("\ns=%4d l=%4d: "),s,l);
for (d=0; d<=4096-l; d+=229)
{
DoTest(pBuf1,pBuf2,4096,s,d,l,0);
DoTest(pBuf1,pBuf2,4096,s,d,l,1);
}
}
}
for (l=1; l<300; l+=3)
{
for (s=4096-l; s>=0; s-=227)
{
test.Printf(_L("\ns=%4d l=%4d: "),s,l);
for (d=4096-l; d>=0; d-=229)
{
DoTest(pBuf1,pBuf2,4096,s,d,l,0);
DoTest(pBuf1,pBuf2,4096,s,d,l,1);
}
}
}
for (l=1; l<400; l+=((l<=64)?1:3) )
{
test.Printf(_L("\nOverlap test: l=%4d: "),l);
for (s=32; s<=4096-32-l; s+=101) // want s to take all values 0...31 modulo 32
{
for (d=s-32; d<=s+32; ++d)
{
DoOverlapTest(pBuf1,pBuf2,4096,s,d,l);
}
}
}
c.Close();
test.End();
return 0;
}
TInt E32Main()
{
TheTest.Title();
CTrapCleanup* tc = CTrapCleanup::New();
TheTest(tc != NULL);
__UHEAP_MARK;
TRAPD(err, DoTestsL());
DestroyTestEnv();
TEST2(err, KErrNone);
__UHEAP_MARKEND;
TheTest.End();
TheTest.Close();
delete tc;
User::Heap().Check();
return KErrNone;
}
/**
@SYMTestCaseID SYSLIB-BAFL-CT-0436
@SYMTestCaseDesc TResourceReader class functionality test
Test for TResourceReader::ReadInt32 (),TResourceReader::ReadTPtrC() functions
@SYMTestPriority High
@SYMTestActions Attempt for reading MENU_BAR resource
@SYMTestExpectedResults Tests must not fail
@SYMREQ REQ0000
*/
void TRsReadTester::TestMenuBarL()
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0436 Test reading MENU_BAR resource "));
TResourceReader reader;
CreateResourceReaderLC(reader,SYS_MENUBAR_ONE);
test(reader.ReadInt16()==8); // how many items following
TPtrC ref=_L("abcdefgh");
for (TInt ii=1; ii<=8; ii++)
{
test(reader.ReadInt32()==ii);
test(reader.ReadTPtrC()==ref.Left(ii));
}
CleanupStack::PopAndDestroy(1);
}
/**
@SYMTestCaseID SYSLIB-BAFL-CT-0437
@SYMTestCaseDesc Reading ALIGNMENT_HORROR resources test
Test for TResourceReader::ReadTPtrC8(),TResourceReader::ReadTPtrC16() function
@SYMTestPriority High
@SYMTestActions Tests for reading descriptors and checks for alignment
@SYMTestExpectedResults Tests must not fail
@SYMREQ REQ0000
*/
void TRsReadTester::TestAlignment1L()
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0437 Test reading ALIGNMENT_HORROR resources "));
TPtrC8 ref8 =_L8("xyz");
TPtrC16 ref16=_L16("xyz");
TResourceReader reader;
for (TInt rr=0; horrors[rr]!=0; rr++)
{
CreateResourceReaderLC(reader,horrors[rr]);
test(reader.ReadTPtrC8() ==ref8.Left(rr));
test(reader.ReadTPtrC16()==ref16.Left(rr));
CleanupStack::PopAndDestroy(1);
}
}
void SelfTests()
{
test.Next(_L("Running framework unit tests"));
#ifndef __WINS__
// Cannot connect real driver on Emulator - only
// simulator
RDmaSession::SelfTest(EFalse);
#endif
RDmaSession::SelfTest(ETrue);
TDmaCapability::SelfTest();
TTestCase::SelfTest();
TTransferIter::SelfTest();
TCallbackRecord::SelfTest();
CDmaBmFragmentation::SelfTest();
TAddrRange::SelfTest();
TAddressParms::SelfTest();
TIsrRequeArgsSet::SelfTest();
RArrayCopyTestL();
RArrayInsertLTest();
TPreTransferIncrBytes::SelfTest();
test.End();
test.Close();
}
void CreateDatabaseL(const TDesC& aDbName)
{
// create the database now
RSqlSecurityPolicy securityPolicy;
CleanupClosePushL(securityPolicy);
TSecurityPolicy policy(TSecurityPolicy::EAlwaysPass);
securityPolicy.Create(policy);
TSecurityPolicy schemaPolicy(TSecurityPolicy::EAlwaysPass);
TSecurityPolicy readPolicy(TSecurityPolicy::EAlwaysPass);
TSecurityPolicy writePolicy(TSecurityPolicy::EAlwaysPass);
User::LeaveIfError(securityPolicy.SetDbPolicy(RSqlSecurityPolicy::ESchemaPolicy, schemaPolicy));
User::LeaveIfError(securityPolicy.SetDbPolicy(RSqlSecurityPolicy::EReadPolicy, readPolicy));
User::LeaveIfError(securityPolicy.SetDbPolicy(RSqlSecurityPolicy::EWritePolicy, writePolicy));
TheTest.Printf(_L("Creating Database %S\n"), &aDbName);
TInt err = TheDbC.Create(aDbName, securityPolicy, &TheSqlConfigString);
if (KErrAlreadyExists == err)
{
// the file already exists
// make sure we delete the file
User::LeaveIfError(TheDbC.Delete(aDbName));
// try again
err = TheDbC.Create(aDbName, securityPolicy, &TheSqlConfigString);
}
User::LeaveIfError(err);
//Create tables
User::LeaveIfError(TheDbC.Exec(KMusicCreateTable));
User::LeaveIfError(TheDbC.Exec(KAuxiliaryCreateTable));
User::LeaveIfError(TheDbC.Exec(KAlbumCreateTable));
User::LeaveIfError(TheDbC.Exec(KArtistCreateTable));
User::LeaveIfError(TheDbC.Exec(KComposerCreateTable));
User::LeaveIfError(TheDbC.Exec(KGenreCreateTable));
User::LeaveIfError(TheDbC.Exec(KPlaylistCreateTable));
User::LeaveIfError(TheDbC.Exec(KPlaylistSongInfoCreateTable));
User::LeaveIfError(TheDbC.Exec(KPlaylistSongsCreateTable));
TheDbC.Close();
CleanupStack::PopAndDestroy(&securityPolicy);
}
TInt E32Main()
//
// Benchmark for euser assmblerised functions
//
{
CTrapCleanup* trapHandler=CTrapCleanup::New();
test(trapHandler!=NULL);
test.Title();
test.Start(_L("Benchmarks for assemblerised euser functions"));
TUserBenchmarkList bms;
TRAPD(err, RunBenchmarkTestsL(bms));
if (err != KErrNone)
test.Printf(_L("TestMainL left with %d\n"), err);
FailIfError(err);
test.End();
delete trapHandler;
return(KErrNone);
}
void CTestXonXoff::RunL()
{
iCount = 0;
iState = EIdle;
iSeed = 1;
Test.Printf(_L("Waiting for Port\r\n"));
ZeroTerminate();
iWriter->Ready();
iTimer->After(1000000);
// iState = EWaitReady;
// WriteComplete(0);
}
/**
@SYMTestCaseID PDS-CENTRALREPOSITORY-CT-4058
@SYMTestCaseDesc Test that settings information can be selectively overridden on many ROFS layers when
the keyspace is not represented on all ROFS layers
@SYMTestPriority High
@SYMTestActions Open keyspace 0x10286557. This keyspace is represented by three
txt files. The keyspace file names in the source have been mangled in a similar way to that
which would be expected on the device (eg. abcd1234.txt, abcd1234.txt[01-00], abcd1234.txt[02-00] etc.
@SYMTestExpectedResults Ensure that the final values of the settings are as specified in the final ROFS layer.
@SYMREQ REQ11401
*/
LOCAL_C void MissingRofsLayerL()
{
TheTest.Next(_L( " @SYMTestCaseID:PDS-CENTRALREPOSITORY-CT-4058 " ));
CRepository* rep;
User::LeaveIfNull(rep = CRepository::NewLC(KUidKeyspace8));
TInt settingValueInt = 0;
// tests that the core value is modified
rep->Get(KKeyOne, settingValueInt);
TEST2(settingValueInt, KKeyspace8Setting1Value);
CleanupStack::PopAndDestroy(rep);
}
TInt E32Main()
{
__UHEAP_MARK;
test.Start(_L("@SYMTESTCaseID:PIM-T-RECURRENCE-0001 t_recurrence"));
test.Title();
CActiveScheduler* scheduler = new CActiveScheduler;
CActiveScheduler::Install(scheduler);
CTrapCleanup* cleanupTrap = CTrapCleanup::New();
TRAPD(ret, RunTestsL());
test(ret==KErrNone);
delete cleanupTrap;
delete scheduler;
test.End();
test.Close();
__UHEAP_MARKEND;
return KErrNone;
}
TInt E32Main()
{
__UHEAP_MARK;
CTrapCleanup* tc = CTrapCleanup::New();
TEST(tc != NULL);
TInt err = TheDbs.Connect();
TEST2(err, KErrNone);
TRAP(err, ::DoRunL());
TEST2(err, KErrNone);
::CleanupTest();
TheTest.End();
TheTest.Close();
delete tc;
__UHEAP_MARKEND;
User::Heap().Check();
return KErrNone;
}
