enum TVerdict CEsockTest11_4::easyTestStepL()
{
//
// Out Of Memory Test on open() RSocket //
//
TVerdict verdict = EPass;
Logger().WriteFormat(_L("TE_ESock: test 11.4"));
Logger().WriteFormat(_L("RSocket Open"));
#if defined (_DEBUG_SOCKET_FUNCTIONS)
RSocketServ socketHelper;
CleanupClosePushL(socketHelper);
TInt ret = socketHelper.Connect();
TESTEL(KErrNone == ret, ret);
// Create a socket on the helper to get the DND up & running
RSocket sockHelper;
CleanupClosePushL(sockHelper);
ret = sockHelper.Open(socketHelper, KAfInet, KSockStream, KProtocolInetTcp);
TESTEL(KErrNone == ret, ret);
// Short wait for DND settle down
User::After(5000000);
socketHelper.__DbgMarkHeap();
RSocketServ socketServer;
CleanupClosePushL(socketServer);
ret = socketServer.Connect();
TESTEL(KErrNone == ret, ret);
// See if we can crash the server:
RSocket sock;
CleanupClosePushL(sock);
TInt failure = 0;
verdict = EInconclusive;
TInt prevResult = KErrNoMemory;
TInt prevOccurs = 0;
while (EInconclusive == verdict)
{
socketServer.__DbgFailNext(failure++);
ret = sock.Open(socketServer, KAfInet, KSockStream, KProtocolInetTcp);
if ((prevResult != ret) || (++prevOccurs >= 1000))
{
Logger().WriteFormat(_L("%d loop(s), open socket returned %d"), prevOccurs, prevResult);
if (KErrNone == ret)
{
verdict = EPass;
}
else if (KErrServerTerminated == ret)
{
verdict = EFail;
}
else if (prevResult != ret)
{
prevResult = ret;
prevOccurs = 1;
}
else
{
prevOccurs = 0;
}
}
};
socketServer.__DbgFailNext(-1);
// wait for protocol families to unload - it's via an async callback and dependent upon the IP stack, which
// may also be killing off DND. So a big delay is needed. If it proves unreliable in future then the really
// strong approach would be shutting down ESOCK - it'll panic if it has allocations outstanding
User::After(5000000);
socketHelper.__DbgMarkEnd(0);
CleanupStack::PopAndDestroy(4, &socketHelper);
#else
Logger().WriteFormat(_L("Test disabled on release build."));
#endif
return verdict;
}
