/**
@SYMTestCaseID SYSLIB-DBMS-CT-0587
@SYMTestCaseDesc CDbColSet class test
@SYMTestPriority Medium
@SYMTestActions Tests for creation of a CDbColSet column set object
Tests for adding and removing columns to the column set
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ0000
*/
LOCAL_C void TestCDbColSetL()
{
TInt r;
test.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0587 ctor and dtor "));
CDbColSet* c=CDbColSet::NewL(); // assume it will succeed
test(c!=NULL);
test (c->Count()==0);
delete c;
__UHEAP_CHECK(0);
#if defined(_DEBUG)
__UHEAP_FAILNEXT(1);
TRAP(r,c=CDbColSet::NewL());
test(r!=KErrNone);
__UHEAP_CHECK(0);
#endif
c=CDbColSet::NewLC();
test(c!=NULL);
CleanupStack::PopAndDestroy();
__UHEAP_CHECK(0);
c=CDbColSet::NewL();
TDbCol col(KColName,EDbColText,20);
c->AddL(col);
delete c;
__UHEAP_CHECK(0);
TRAP(r,c=CDbColSet::NewLC();c->AddL(col);User::Leave(KLeaveError););
/**
* Checks that the number of allocated cells at the current nested level on
* the server's heap is the same as the specified value. This function only
* works for debug builds.
*
* @param aCount The number of heap cells expected to be allocated at
* the current nest level.
*
* @return KErrNone.
*/
TInt CShBufTestServer::DbgCheckHeap(TInt aCount) const
{
#ifdef _DEBUG
__UHEAP_CHECK(aCount);
#else
(void) aCount;
#endif
return(KErrNone);
} // CShBufTestServer::DbgCheckHeap
void tst_qmainexceptions::cleanupstack()
{
__UHEAP_MARK;
//fails if OOM
CDummy* dummy1 = new (ELeave) CDummy;
__UHEAP_CHECK(1);
CleanupStack::PushL(dummy1);
CleanupStack::PopAndDestroy(dummy1);
__UHEAP_MARKEND;
}
//
// Testing the DBMS for failure modes
//
LOCAL_C void doMainL()
{
test.Start(_L("Class RDbNamedDatabase"));
__UHEAP_MARK;
OriginsL();
__UHEAP_CHECK(0);
__UHEAP_MARK;
Origins2();
__UHEAP_CHECK(0);
test.Next(_L("Class RDbDatabase"));
DatabaseL();
__UHEAP_CHECK(0);
test.Next(_L("Class RDbTable"));
TableL();
__UHEAP_CHECK(0);
test.Next(_L("Class RDbView"));
ViewL();
__UHEAP_MARKEND;
test.End();
}
LOCAL_C void DatabaseL()
{
test.Start(_L("Adding and dropping tables"));
DbCreateL();
// ensure the database locking list has been allocated
TheDatabase.Begin();
TheDatabase.Commit();
//
CDbColSet *col=CDbColSet::NewLC();
//
test.Next(_L("Empty Column Set"));
__UHEAP_MARK;
test(TheDatabase.CreateTable(TableName,*col)!=KErrNone);
__UHEAP_MARKEND;
//
test.Next(_L("Invalid table name"));
col->AddL(TDbCol(Column1,EDbColInt32));
__UHEAP_MARK;
test(TheDatabase.CreateTable(TableNameX,*col)!=KErrNone);
__UHEAP_MARKEND;
//
test.Next(_L("Invalid column name"));
col->AddL(TDbCol(Column2X,EDbColBit));
__UHEAP_MARK;
test(TheDatabase.CreateTable(TableName,*col)!=KErrNone);
__UHEAP_MARKEND;
//
test.Next(_L("Duplicate column name"));
col->Remove(Column2X);
col->AddL(TDbCol(Column1Fold,EDbColBit));
__UHEAP_MARK;
test(TheDatabase.CreateTable(TableName,*col)!=KErrNone);
__UHEAP_MARKEND;
//
test.Next(_L("Invalid column type"));
col->Remove(Column1);
col->AddL(TDbCol(Column2,TDbColType(-1)));
__UHEAP_MARK;
test(TheDatabase.CreateTable(TableName,*col)!=KErrNone);
__UHEAP_MARKEND;
//
test.Next(_L("Invalid maximum length"));
col->Remove(Column2);
col->AddL(TDbCol(Column2,EDbColInt32,0));
__UHEAP_MARK;
test(TheDatabase.CreateTable(TableName,*col)!=KErrNone);
__UHEAP_MARKEND;
//
test.Next(_L("Invalid attributes"));
col->Remove(Column2);
TDbCol cc(Column2,EDbColInt32);
cc.iAttributes=13;
col->AddL(cc);
__UHEAP_MARK;
test(TheDatabase.CreateTable(TableName,*col)!=KErrNone);
__UHEAP_MARKEND;
//
test.Next(_L("Adding/dropping a table name twice"));
col->Remove(Column2);
col->AddL(TDbCol(Column2,EDbColText8));
__UHEAP_MARK;
test(TheDatabase.CreateTable(TableName,*col)==KErrNone);
test(TheDatabase.CreateTable(TableName,*col)==KErrAlreadyExists);
test(TheDatabase.DropTable(TableNameX)!=KErrNone);
test(TheDatabase.DropTable(TableName)==KErrNone);
test(TheDatabase.DropTable(TableName)==KErrNotFound);
__UHEAP_MARKEND;
//
test.Next(_L("Adding and dropping indexes"));
test(TheDatabase.CreateTable(TableName,*col)==KErrNone);
TheDatabase.Close();
CDbKey *key=CDbKey::NewLC();
__UHEAP_MARK;
DbOpenL();
test(TheDatabase.CreateIndex(IndexName,TableName,*key)!=KErrNone);
TheDatabase.Close();
__UHEAP_MARKEND;
key->AddL(Column2X());
__UHEAP_MARK;
DbOpenL();
test(TheDatabase.CreateIndex(IndexName,TableName,*key)!=KErrNone);
TheDatabase.Close();
__UHEAP_MARKEND;
key->Clear();
key->AddL(Column1());
__UHEAP_MARK;
DbOpenL();
test(TheDatabase.CreateIndex(TableNameX,TableName,*key)!=KErrNone);
TheDatabase.Close();
__UHEAP_CHECK(0);
DbOpenL();
test(TheDatabase.CreateIndex(IndexName,TableNameX,*key)!=KErrNone);
TheDatabase.Close();
__UHEAP_MARKEND;
__UHEAP_MARK;
DbOpenL();
test(TheDatabase.CreateIndex(IndexName,TableName,*key)==KErrNone);
test(TheDatabase.CreateIndex(IndexName,TableName,*key)==KErrAlreadyExists);
test(TheDatabase.DropIndex(TableNameX,TableName)!=KErrNone);
test(TheDatabase.DropIndex(IndexName,TableNameX)!=KErrNone);
test(TheDatabase.DropIndex(IndexName,TableName)==KErrNone);
test(TheDatabase.DropIndex(IndexName,TableName)==KErrNotFound);
test(TheDatabase.DropTable(TableName)==KErrNone);
test(TheDatabase.DropIndex(IndexName,TableName)==KErrNotFound);
TheDatabase.Close();
__UHEAP_MARKEND;
//
test.Next(_L("Allocation failure during DDL"));
TFailCreateTable fct;
TFailAlterTable fat;
TFailDropTable fdt;
TFailCreateIndex fci;
TFailDropIndex fdi;
TheColSet=CDbColSet::NewL();
TheColSet->AddL(TDbCol(Column1,EDbColUint16));
TheKey=CDbKey::NewL();
TheKey->AddL(Column1());
fct.Test(KClientHeap,KClient);
WriteTableL();
TheColSet->AddL(TDbCol(Column2,EDbColText));
fat.Test(KClientHeap,KClient);
fci.Test(KClientHeap,KClient);
fdi.Test(KClientHeap,KClient);
fdt.Test(KClientHeap,KClient);
//
test.Next(_L("Allocation failure during server DDL"));
Connect();
TheColSet->Remove(Column2);
fct.Test(KClientHeap,KServer);
WriteTableL();
TheColSet->AddL(TDbCol(Column2,EDbColText));
fat.Test(KClientHeap,KServer);
fci.Test(KClientHeap,KServer);
fdi.Test(KClientHeap,KServer);
fdt.Test(KClientHeap,KServer);
//
TheColSet->Remove(Column2);
fct.Test(KServerHeap,KServer);
WriteTableL();
TheColSet->AddL(TDbCol(Column2,EDbColText));
fat.Test(KServerHeap,KServer);
fci.Test(KServerHeap,KServer);
fdi.Test(KServerHeap,KServer);
fdt.Test(KServerHeap,KServer);
Disconnect();
//
delete TheColSet;
delete TheKey;
//
test.Next(_L("Allocation failure on schema enquiry"));
DbCreateL();
test(TheDatabase.CreateTable(TableName,*col)==KErrNone);
test(TheDatabase.CreateIndex(IndexName,TableName,*key)==KErrNone);
CleanupStack::PopAndDestroy(2); // columns set and key
TheDatabase.Close();
TFailDatabaseTables t4;
TFailDatabaseColSet t5;
TFailDatabaseIndexes t6;
TFailDatabaseKeys t7;
t4.Test(KClientHeap,KClient);
t5.Test(KClientHeap,KClient);
t6.Test(KClientHeap,KClient);
t7.Test(KClientHeap,KClient);
//
test.Next(_L("Allocation failure on server schema enquiry"));
Connect();
t4.Test(KClientHeap,KServer);
t4.Test(KServerHeap,KServer);
t5.Test(KClientHeap,KServer);
t5.Test(KServerHeap,KServer);
t6.Test(KClientHeap,KServer);
t6.Test(KServerHeap,KServer);
t7.Test(KClientHeap,KServer);
t7.Test(KServerHeap,KServer);
Disconnect();
test.End();
}
void CCommSession::ServiceL(const RMessage2& aMessage)
/**
* Handle messages for this session.
*
* @param aMessage handle to the IPC message from the client
*/
{
C32LOG5(KC32Detail,_L8("CCommSession::ServiceL(), Session : 0x%x, IPC: %d (%S). Message: %08x"), this, aMessage.Function(), &TC32Log::C32RequestStr(aMessage.Function()),aMessage.Handle());
iComplete = ETrue;
const CC32WorkerThread& owner=C32WorkerThread();
CC32Dealer& c32Dealer = owner.DealerByRef();
if (c32Dealer.StartupFailed())
{
SafeComplete(aMessage, KErrNotReady);
return;
}
// TestImmediateShutdownPresent is only set when EImmediate shutdown is present, which is
// used only in testing phase.
if(c32Dealer.TestImmediateShutdownPresent())
{
User::Leave(KErrServerTerminated);
}
if((aMessage.Function()==ECommOpen)
||
(aMessage.Function()==ECommOpenWhenAvailable))
{
NewPortL(aMessage);
return;
}
#if defined (_DEBUG)
switch (aMessage.Function())
{
case ECommDbgMarkHeap:
__UHEAP_MARK;
SafeComplete(aMessage, KErrNone);
return;
case ECommDbgCheckHeap:
__UHEAP_CHECK(aMessage.Int0());
SafeComplete(aMessage, KErrNone);
return;
case ECommDbgMarkEnd:
__UHEAP_MARKENDC(aMessage.Int0());
SafeComplete(aMessage, KErrNone);
return;
case ECommDbgFailNext:
// We set the fail point for all heaps, rather than just the current Dealer. This could lead to a failure not related
// directly to whatever the client test code is trying to exercise but it all helps find bugs
c32Dealer.SetFailNextForAllHeaps(aMessage.Int0());
SafeComplete(aMessage, KErrNone);
return;
}
#endif
switch ((aMessage.Function()))
{
case ECommLoadCommModule:
{
TFileName fullCSYFilename;
TInt ret = Read(0,aMessage,fullCSYFilename);
if (ret != KErrNone)
{
C32LOG2(KC32Warning, _L8("ServiceL: LoadCommModule Read returned %d instead of KErrNone, cannot proceed"), ret);
PanicClient(EBadDescriptor,aMessage);
return;
}
ret = AddCSYExtension(fullCSYFilename,aMessage);
if(ret != KErrNone)
{
C32LOG2(KC32Warning, _L8("ServiceL: LoadCommModule AddCSYExtension returned %d instead of KErrNone, cannot proceed"), ret);
return;
}
CommsFW::TWorkerId worker;
TBuf8<KMaxFileName> fileName8;
fileName8.Copy(fullCSYFilename);
TBool found = iThreadManager->FindThreadByFileName(fileName8, worker);
if(!found)
{
worker = iThreadManager->iDefaultThreadIndex;
}
if(c32Dealer.WorkerExists(worker))
{
LoadCommModuleL(aMessage,worker,!found,fullCSYFilename);
}
else
{
C32LOG2(KC32Dealer,_L8("ServiceL: LoadCommModule requires worker %d. This worker does not exist so starting"),worker);
ret = c32Dealer.LoadCPMOnLoadCommModule(worker);
if ((ret!=KErrNone) && (ret!=KErrInUse))
{
// only likely return codes here are KErrNoMemory or KErrNotFound if
// the RS server could not be found - which means system is probably in pretty bad state (ie, no memory)
// luckily at this point there isn't anything to clean up!
SafeComplete(aMessage,ret);
}
else
{
ret = c32Dealer.ParkRequest(this, aMessage);
if(ret != KErrNone)
{
SafeComplete(aMessage, ret);
}
}
}
return;
}
case ECommCloseCommModule:
CloseCommModuleL(aMessage);
return;
case ECommPortInfoByName:
{
TPortName name;
TInt ret = Read(1,aMessage,name);
if (ret != KErrNone)
{
C32LOG2(KC32Warning, _L8("ServiceL: LoadCommModule Read returned %d instead of KErrNone, cannot proceed"), ret);
PanicClient(EBadDescriptor,aMessage);
return;
}
PortInfoL(aMessage,name);
return;
}
case ECommPortInfoByNumber: // original msg is not forwarded as global as aMessage.Int2() is not valid in player, instead CSerial* is wrapped in TC32PlayerGetPortInfoMsg
PortInfo(aMessage,aMessage.Int2());
return;
case ECommNumPorts: // get information from ThreadManager in dealer
NumPorts(aMessage);
return;
case ECommStartServerThread: // KErrNotSupported
C32LOG2(KC32Dealer, _L8("WARNING: deprecated function ECommStartServerThread called, CCommSession(%08x)"), this);
SafeComplete(aMessage, KErrNotSupported);
return;
}
// obtain subsession* from aMessage.Int3()
CCommSubSession *p = SubSessionFromHandle(aMessage.Int3(), CCommSubSession::ECPort);
if (aMessage.Function()==ECommClose)
{
if (p==NULL) // not a valid aMessage.Int3()
{
SafeComplete(aMessage, KErrBadHandle);
return;
}
else
{
CloseSubSessionL(aMessage, CCommSubSession::ECPort);
return;
}
}
if (p==NULL) // not a valid aMessage.Int3()
{
PanicClient(EBadCommHandle, aMessage);
return;
}
// Its OK to proceed with the dispatch of other requests
switch (aMessage.Function())
{
case ECommRead:
case ECommReadCancel:
case ECommQueryReceiveBuffer:
case ECommResetBuffers:
case ECommWrite:
case ECommWriteCancel:
case ECommBreak:
case ECommBreakCancel:
case ECommCancel:
case ECommConfig:
case ECommSetConfig:
case ECommCaps:
case ECommSetMode:
case ECommGetMode:
case ECommSignals:
case ECommSetSignalsToMark:
case ECommSetSignalsToSpace:
case ECommReceiveBufferLength:
case ECommSetReceiveBufferLength:
case ECommSetAccess:
case ECommOpenWhenAvailableCancel:
#ifdef _DEBUG
case ECommDebugState:
#endif
// Extensions to the CCommSession starts from here
case ECommNotifySignals:
case ECommNotifyFlowControl:
case ECommNotifySignalsCancel:
case ECommNotifyFlowControlCancel:
case ECommGetFlowControl:
case ECommNotifyConfigChange:
case ECommNotifyConfigChangeCancel:
case ECommNotifyBreak:
case ECommNotifyBreakCancel:
case ECommGetRole:
case ECommNotifyDataAvailable:
case ECommNotifyDataAvailableCancel:
case ECommNotifyOutputEmpty:
case ECommNotifyOutputEmptyCancel:
ForwardMessageL(aMessage, *p);
break;
// Extensions to the CCommSession ends to here
default:
SafeComplete(aMessage, KErrNotSupported);
break;
}
C32LOG(KC32Detail,_L8("CCommSession::ServiceL() end"));
}
