void CTModifiersChangedTest::CheckModifierL(TEventModifier aModifier)
{
TInt oldMods=Client()->iWs.GetModifierState();
Client()->iWs.SetModifierState(aModifier, EToggleModifier);
TInt getMods=Client()->iWs.GetModifierState();
if (oldMods!=getMods)
{
iSettable|=aModifier;
Client()->iWs.SetModifierState(aModifier, ETurnOffModifier);
getMods=Client()->iWs.GetModifierState();
TestL(!(getMods&aModifier));
Client()->iWs.SetModifierState(aModifier, ETurnOnModifier);
getMods=Client()->iWs.GetModifierState();
TestL(getMods&aModifier);
Client()->iWs.SetModifierState(aModifier, ETurnOffModifier);
getMods=Client()->iWs.GetModifierState();
TestL(!(getMods&aModifier));
if (oldMods&aModifier)
Client()->iWs.SetModifierState(aModifier, ETurnOnModifier);
}
else
{
Client()->iWs.SetModifierState(aModifier, ETurnOffModifier);
TestL(oldMods==Client()->iWs.GetModifierState());
Client()->iWs.SetModifierState(aModifier, ETurnOnModifier);
TestL(oldMods==Client()->iWs.GetModifierState());
}
}
void CHttpHdrTest::TestRemovePartL()
{
// Open strings needed in this test
RStringF accStr = iStrP.StringF(HTTP::EAccept,RHTTPSession::GetTable());
RStringF textHtmlStr = iStrP.StringF(HTTP::ETextHtml,RHTTPSession::GetTable());
RStringF textPlainStr = iStrP.StringF(HTTP::ETextPlain,RHTTPSession::GetTable());
RStringF anyAnyStr = iStrP.StringF(HTTP::EAnyAny,RHTTPSession::GetTable());
RStringF qStr = iStrP.StringF(HTTP::EQ,RHTTPSession::GetTable());
//
// Accept: text/html; q=0.8, text/plain; q=0.2, */*
//
CHeaderField* accept = CHeaderField::NewL(accStr, *iHdrColl);
CleanupStack::PushL(accept);
//
CHeaderFieldPart* htmlPt = CHeaderFieldPart::NewL(THTTPHdrVal(textHtmlStr));
CleanupStack::PushL(htmlPt);
THTTPHdrVal::TQConv q(0.2);
CHeaderFieldParam* headerParam = CHeaderFieldParam::NewL(qStr, THTTPHdrVal(q));
CleanupStack::PushL(headerParam);
htmlPt->AddParamL(headerParam);
CleanupStack::Pop(headerParam);
accept->AddPartL(htmlPt);
CleanupStack::Pop(htmlPt); // htmlPt - now owned by the header
//
CHeaderFieldPart* plainPt = CHeaderFieldPart::NewL(THTTPHdrVal(textPlainStr));
CleanupStack::PushL(plainPt);
headerParam = CHeaderFieldParam::NewL(qStr, THTTPHdrVal(q));
CleanupStack::PushL(headerParam);
plainPt->AddParamL(headerParam);
CleanupStack::Pop(headerParam);
accept->AddPartL(plainPt);
CleanupStack::Pop(plainPt); // plainPt - now owned by the header
//
CHeaderFieldPart* headerPart = CHeaderFieldPart::NewL(anyAnyStr);
CleanupStack::PushL(headerPart);
accept->AddPartL(headerPart);
CleanupStack::Pop(headerPart);
// now remove the parts
TestL(accept->RemovePartL(0) == KErrNone); // removes htmlPt
TestL(accept->RemovePartL(1) == KErrNone); // removes '*/*' part...
// Attempting to remove a non-existent part should fail somehow
TestL(accept->RemovePartL(2) == KErrNotFound);
// remove the final part
TestL(accept->RemovePartL(0) == KErrNone); // removes plainPt
// Now just destroy that lot
CleanupStack::PopAndDestroy(); // accept
}
void CHttpHdrTest::TestLookupPartL()
{
// Open strings needed in this test
RStringF accStr = iStrP.StringF(HTTP::EAccept,RHTTPSession::GetTable());
RStringF textHtmlStr = iStrP.StringF(HTTP::ETextHtml,RHTTPSession::GetTable());
RStringF textPlainStr = iStrP.StringF(HTTP::ETextPlain,RHTTPSession::GetTable());
RStringF anyAnyStr = iStrP.StringF(HTTP::EAnyAny,RHTTPSession::GetTable());
RStringF qStr = iStrP.StringF(HTTP::EQ,RHTTPSession::GetTable());
//
// Accept: text/html; q=0.8, text/plain; q=0.2, */*
//
CHeaderField* accept = CHeaderField::NewL(accStr, *iHdrColl);
CleanupStack::PushL(accept);
//
CHeaderFieldPart* htmlPt = CHeaderFieldPart::NewL(THTTPHdrVal(textHtmlStr));
CleanupStack::PushL(htmlPt);
THTTPHdrVal::TQConv q(0.8);
CHeaderFieldParam* headerParam = CHeaderFieldParam::NewL(qStr, THTTPHdrVal(q));
CleanupStack::PushL(headerParam);
htmlPt->AddParamL(headerParam);
CleanupStack::Pop(headerParam);
accept->AddPartL(htmlPt);
CleanupStack::Pop(htmlPt); // now owned by the header
//
CHeaderFieldPart* plainPt = CHeaderFieldPart::NewL(THTTPHdrVal(textPlainStr));
CleanupStack::PushL(plainPt);
THTTPHdrVal::TQConv q2(0.2);
headerParam = CHeaderFieldParam::NewL(qStr, THTTPHdrVal(q2));
CleanupStack::PushL(headerParam);
plainPt->AddParamL(headerParam);
CleanupStack::Pop(headerParam);
accept->AddPartL(plainPt);
CleanupStack::Pop(plainPt); // now owned by the header
//
CHeaderFieldPart* headerPart = CHeaderFieldPart::NewL(THTTPHdrVal(anyAnyStr));
CleanupStack::PushL(headerPart);
accept->AddPartL(headerPart);
CleanupStack::Pop(headerPart);
// now lookup the parts by index and check they are correct
CHeaderFieldPart* pt = accept->PartL(0);
TestL(pt == htmlPt);
pt = accept->PartL(1);
TestL(pt == plainPt);
pt = accept->PartL(2);
THTTPHdrVal val = pt->Value();
TestL(val.Type() == THTTPHdrVal::KStrFVal);
TestL(val.StrF().Index(RHTTPSession::GetTable()) == anyAnyStr.Index(RHTTPSession::GetTable()));
// Now just destroy that lot
CleanupStack::PopAndDestroy(accept);
}
void CHttpHdrTest::TestLookupParamL()
{
// Open strings needed in this test
RStringF qStr = iStrP.StringF(HTTP::EQ,RHTTPSession::GetTable());
RStringF textHtmlStr = iStrP.StringF(HTTP::ETextHtml,RHTTPSession::GetTable());
RStringF user1Str = iStrP.OpenFStringL(_L8("user1"));
CleanupClosePushL(user1Str);
RStringF value1Str = iStrP.OpenFStringL(_L8("value1"));
CleanupClosePushL(value1Str);
RStringF user2Str = iStrP.OpenFStringL(_L8("user2"));
CleanupClosePushL(user2Str);
RStringF value2Str = iStrP.OpenFStringL(_L8("value2"));
CleanupClosePushL(value2Str);
//
CHeaderFieldPart* htmlPt = CHeaderFieldPart::NewL(THTTPHdrVal(textHtmlStr));
CleanupStack::PushL(htmlPt);
THTTPHdrVal::TQConv q(0.2);
CHeaderFieldParam* headerParam = CHeaderFieldParam::NewL(qStr, THTTPHdrVal(q));
CleanupStack::PushL(headerParam);
htmlPt->AddParamL(headerParam);
CleanupStack::Pop(headerParam);
headerParam = CHeaderFieldParam::NewL(user1Str, THTTPHdrVal(value1Str));
CleanupStack::PushL(headerParam);
htmlPt->AddParamL(headerParam);
CleanupStack::Pop(headerParam);
headerParam = CHeaderFieldParam::NewL(user2Str, THTTPHdrVal(value2Str));
CleanupStack::PushL(headerParam);
htmlPt->AddParamL(headerParam);
CleanupStack::Pop(headerParam);
//
// now lookup the params
CHeaderFieldParam* qP = htmlPt->Parameter(qStr);
RStringF qPstr = qP->Name();
TestL(qPstr.Index(RHTTPSession::GetTable()) == qStr.Index(RHTTPSession::GetTable()));
//
qP = htmlPt->Parameter(user1Str);
qPstr = qP->Name();
TestL(qPstr.Index(RHTTPSession::GetTable()) == user1Str.Index(RHTTPSession::GetTable()));
//
qP = htmlPt->Parameter(user2Str);
qPstr = qP->Name();
TestL(qPstr.Index(RHTTPSession::GetTable()) == user2Str.Index(RHTTPSession::GetTable()));
// Now just destroy that lot
CleanupStack::PopAndDestroy(5);
}
TInt TKRepeatTest::CheckReportL()
{
if (iWin->CheckResults())
{
CTDialog *dialog=new(ELeave) CTDialog();
dialog->SetTitle(_L("Keyboard repeat innacuracies"));
dialog->SetLine1(iWin->Report());
dialog->SetNumButtons(2);
dialog->SetButtonText(0,_L("Okay"));
dialog->SetButtonText(1,_L("Retest"));
dialog->SetButtonText(2,_L("Fail"));
dialog->ConstructLD(*Client()->iGroup,*Client()->iGc);
switch(dialog->Display())
{
case 0:
break;
case 1:
return(ETrue); // Redo test
case 2:
TestL(EFalse);
break;
}
}
return(EFalse);
}
GLDEF_C TInt E32Main()
//
// Test Help file loading
//
{
__UHEAP_MARK;
TheTest.Title();
TheTest.Start(_L("@SYMTestCaseID PIM-TLOADER-0001"));
TheTest(TheFs.Connect() == KErrNone);
TheTrapCleanup = CTrapCleanup::New();
if (!TheTrapCleanup)
return KErrNoMemory;
TRAPD(r, TestL());
TheTest(r == KErrNone);
delete TheTrapCleanup;
TheFs.Close();
TheTest.End();
TheTest.Close();
__UHEAP_MARKEND;
return KErrNone;
}
void CHttpHdrTest::TestRemoveParamL()
{
// Open strings needed in this test
RStringF qStr = iStrP.StringF(HTTP::EQ,RHTTPSession::GetTable());
RStringF textHtmlStr = iStrP.StringF(HTTP::ETextHtml,RHTTPSession::GetTable());
//
CHeaderFieldPart* htmlPt = CHeaderFieldPart::NewL(THTTPHdrVal(textHtmlStr));
CleanupStack::PushL(htmlPt);
THTTPHdrVal::TQConv q(0.2);
CHeaderFieldParam* headerParam = CHeaderFieldParam::NewL(qStr, THTTPHdrVal(q));
CleanupStack::PushL(headerParam);
htmlPt->AddParamL(headerParam);
CleanupStack::Pop(headerParam);
//
// now remove the params
CHeaderFieldParam* qP = htmlPt->Parameter(qStr);
htmlPt->RemoveParam(qP);
// Attempting to remove a non-existent parameter should fail somehow
TestL(htmlPt->RemoveParam(qP) == KErrNotFound);
// Now just destroy that lot
CleanupStack::PopAndDestroy(htmlPt);
}
void CT_CP949::OOMTestL()
{
INFO_PRINTF1(_L("OOM testing"));
TInt err, tryCount = 0;
do
{
__UHEAP_MARK;
// find out the number of open handles
TInt startProcessHandleCount;
TInt startThreadHandleCount;
RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
// Setting Heap failure for OOM test
__UHEAP_SETFAIL(RHeap::EDeterministic, ++tryCount);
TRAP(err,TestL());
__UHEAP_SETFAIL(RHeap::ENone, 0);
// check that no handles have leaked
TInt endProcessHandleCount;
TInt endThreadHandleCount;
RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
test(startProcessHandleCount == endProcessHandleCount);
test(startThreadHandleCount == endThreadHandleCount);
__UHEAP_MARKEND;
}while (err == KErrNoMemory);
test(err == KErrNone);
INFO_PRINTF2(_L("- server succeeded at heap failure rate of %i\n"), tryCount);
}
// ----------------------------------------------------------------------------
// override the CBCTestCase::RunL, only response to the related command ID.
// ----------------------------------------------------------------------------
//
void CBCTestAknDoc::RunL(int aCmd)
{
if(aCmd != EBCTestCmdDocument) return;
SetupL();
TestL();
TearDownL();
}
// ----------------------------------------------------------------------------
// override the CBCTestCase::RunL, only response to the related command ID.
// ----------------------------------------------------------------------------
//
void CTestVolumeSettingPage::RunL(int aCmd)
{
if(aCmd != EBCTestVolumeCmdOutline01) return;
SetupL();
TestL();
TearDownL();
}
GLDEF_C void TestTDes<T,S,L,R>::test_HBufC()
//
// Test the HBufC class methods.
//
{
test.Start(_L("New"));
Test16();
test.Next(_L("NewL - forcing a leave"));
Test17();
test.Next(_L("NewL - showing success"));
Test18();
test.Next(_L("String assignment"));
TestJ();
test.Next(_L("Descriptor assignment"));
TestK();
test.Next(_L("HBufC assignment"));
TestL();
test.Next(_L("ReAlloc"));
TestM();
test.Next(_L("ReAllocL - forcing a leave"));
TestN();
test.Next(_L("ReAllocL - showing success"));
TestO();
}
int main(int argc, char **argv)
{
PR_STDIO_INIT();
TestI();
TestL();
TestLL();
TestS();
printf("PASS\n");
return 0;
}
GLDEF_C TInt E32Main()
// Main function
{
__UHEAP_MARK;
CTrapCleanup* tc=CTrapCleanup::New();
TRAPD(err,TestL());
if (err!=KErrNone)
User::Panic(KTxtFailed, err);
delete tc;
REComSession::FinalClose();
__UHEAP_MARKEND;
return KErrNone;
}
GLDEF_C TInt E32Main()
//
// Main function
{
__UHEAP_MARK;
CTrapCleanup* tc=CTrapCleanup::New();
TRAPD(err,TestL());
if (err!=KErrNone)
User::Panic(_L("Failed to complete test"),err);
delete tc;
__UHEAP_MARKEND;
return KErrNone;
}
TestState TDummyTest::DoTestL()
{
switch(iState)
{
case 0:
LogSubTest(_L("Dummy 1"),1);
TestL(ETrue);
iState++;
break;
default:
return(EFinished);
}
return(ENext);
}
// ---------------------------------------------------------------------------
// CBCTestScreenClearerCase::RunL
// ---------------------------------------------------------------------------
//
void CBCTestScreenClearerCase::RunL( TInt aCmd )
{
if ( aCmd < EBCTestCmdTestL || aCmd > EBCTestCmdTestL )
{
return;
}
switch ( aCmd )
{
case EBCTestCmdTestL:
TestL();
break;
default:
break;
}
}
TVerdict CT_CP1257::doTestStepL()
{
SetTestStepResult(EFail);
__UHEAP_MARK;
TRAPD(error1, TestL());
TRAPD(error2, OOMTestL());
__UHEAP_MARKEND;
if(error1 == KErrNone && error2 == KErrNone)
{
SetTestStepResult(EPass);
}
return TestStepResult();
}
TestState CPasswordTest::DoTestL()
{
if (iPasswordTestFailed)
TestL(ETrue);
switch(iState)
{
case 0:
LogSubTest(_L("Password 1"),1);
StartMainPasswordTestL();
iState++;
return(EContinue);
case 1:
LogSubTest(_L("Password 2"),2);
StartOnceADayPasswordTestL();
iState++;
return(EContinue);
default:
return(EFinished);
}
}
void CHttpHdrTest::TestHdrValL()
{
// Open strings needed in this test
RStringF accStr = iStrP.OpenFStringL(_L8("Accept"));
THTTPHdrVal v1(accStr);
TestL(CompareStringL(v1.StrF(), _L8("Accept")));
TestL(v1.Type() == THTTPHdrVal::KStrFVal);
THTTPHdrVal v2(3);
TestL(v2.Int() == 3);
TestL(v2.Type() == THTTPHdrVal::KTIntVal);
TDateTime date(2001, EJanuary, 1, 12, 00, 00, 00);
THTTPHdrVal v3(date);
TestL(CompareDate(v3.DateTime(), date));
TestL(v3.Type() == THTTPHdrVal::KDateVal);
THTTPHdrVal v4 = accStr;
TestL(v4.Type() == THTTPHdrVal::KStrFVal);
THTTPHdrVal v5 = 3;
TestL(v5.Type() == THTTPHdrVal::KTIntVal);
THTTPHdrVal v6 = date;
TestL(v6.Type() == THTTPHdrVal::KDateVal);
RStringF str2 = v1;
TestL(str2 == v1.StrF());
TInt ii = v2;
TestL(ii == v2.Int());
TDateTime dt = v3;
TestL(CompareDate(dt, date));
v3 = str2;
TestL(v3.Type() == THTTPHdrVal::KStrFVal);
TestL(str2 == v3);
v3 = 67;
TestL(v3.Type() == THTTPHdrVal::KTIntVal);
TestL(67 == v3);
v3 = date;
TestL(v3.Type() == THTTPHdrVal::KDateVal);
TestL(CompareDate(date, v3.DateTime()));
// Close strings used in this test
accStr.Close();
}
void CHttpHdrTest::TestHeaderCollL()
{
// Open strings needed in this test
RStringF userAgentStr = iStrP.StringF(HTTP::EUserAgent,RHTTPSession::GetTable());
RStringF textPlainStr = iStrP.StringF(HTTP::ETextPlain,RHTTPSession::GetTable());
RStringF qStr = iStrP.StringF(HTTP::EQ,RHTTPSession::GetTable());
RStringF accStr = iStrP.StringF(HTTP::EAccept,RHTTPSession::GetTable());
RStringF textHtmlStr = iStrP.StringF(HTTP::ETextHtml,RHTTPSession::GetTable());
RStringF wmlStr = iStrP.StringF(HTTP::ETextVndWapWml,RHTTPSession::GetTable());
RStringF symbGTWapStr = iStrP.OpenFStringL(_L8("SymbGTWap"));
CleanupClosePushL(symbGTWapStr);
//
CTextModeHeaderCodec* headerCodec = CTextModeHeaderCodec::NewL(iStrP);
CleanupStack::PushL(headerCodec);
CHeaders* headers = CHeaders::NewL(*headerCodec);
CleanupStack::PushL(headers);
RHTTPHeaders hdr = headers->Handle();
THTTPHdrVal uaStr(symbGTWapStr);
hdr.SetFieldL(userAgentStr, uaStr);
THTTPHdrVal dummy;
TestL(hdr.GetField(userAgentStr,0,dummy) == KErrNone);
hdr.RemoveField(userAgentStr);
TestL(hdr.GetField(userAgentStr,0,dummy) == KErrNotFound);
THTTPHdrVal htmlStr(textHtmlStr);
THTTPHdrVal q(THTTPHdrVal::TQConv(0.5));
hdr.SetFieldL(accStr, htmlStr, qStr, q);
THTTPHdrVal wml(wmlStr);
THTTPHdrVal q2(THTTPHdrVal::TQConv(0.3));
hdr.SetFieldL(accStr, wml, qStr, q2);
THTTPHdrVal plainStr(textPlainStr);
THTTPHdrVal q3(THTTPHdrVal::TQConv(0.1));
hdr.SetFieldL(accStr, plainStr, qStr, q3);
TestL(hdr.FieldPartsL(accStr) == 3);
THTTPHdrVal v1;
hdr.GetField(accStr,0,v1);
TestL(v1.Type() == THTTPHdrVal::KStrFVal);
TestL(v1.StrF().Index(RHTTPSession::GetTable()) == textHtmlStr.Index(RHTTPSession::GetTable()));
THTTPHdrVal v2;
TestL(!hdr.GetParam(accStr, qStr, v2));
hdr.GetField(accStr, 1,v2);
TestL(v1.Type() == THTTPHdrVal::KStrFVal);
TestL(v2.StrF().Index(RHTTPSession::GetTable()) == wmlStr.Index(RHTTPSession::GetTable()));
THTTPHdrVal v3;
TestL(!hdr.GetParam(accStr, qStr, v3, 1));
hdr.GetField(accStr, 2,v3);
TestL(v3.Type() == THTTPHdrVal::KStrFVal);
TestL(v3.StrF().Index(RHTTPSession::GetTable()) == textPlainStr.Index(RHTTPSession::GetTable()));
TestL(!hdr.GetParam(accStr, qStr, v3, 2));
CleanupStack::PopAndDestroy(3);
}
void CHttpHdrTest::TestHeaderCollIterL()
{
RStringF field1Str = iStrP.OpenFStringL(_L8("hcfield1"));
CleanupClosePushL(field1Str);
RStringF value1Str = iStrP.OpenFStringL(_L8("hcvalue1"));
CleanupClosePushL(value1Str);
RStringF field2Str = iStrP.OpenFStringL(_L8("hcfield2"));
CleanupClosePushL(field2Str);
RStringF value2Str = iStrP.OpenFStringL(_L8("hcvalue2"));
CleanupClosePushL(value2Str);
RStringF field3Str = iStrP.OpenFStringL(_L8("hcfield3"));
CleanupClosePushL(field3Str);
RStringF value3Str = iStrP.OpenFStringL(_L8("hcvalue3"));
CleanupClosePushL(value3Str);
RStringF field4Str = iStrP.OpenFStringL(_L8("hcfield4"));
CleanupClosePushL(field4Str);
RStringF value4Str = iStrP.OpenFStringL(_L8("hcvalue4"));
CleanupClosePushL(value4Str);
//
CTextModeHeaderCodec* headerCodec = CTextModeHeaderCodec::NewL(iStrP);
CleanupStack::PushL(headerCodec);
CHeaders* headers = CHeaders::NewL(*headerCodec);
CleanupStack::PushL(headers);
RHTTPHeaders hdr = headers->Handle();
THTTPHdrVal str1(value1Str);
hdr.SetFieldL(field1Str, str1);
THTTPHdrVal str2(value2Str);
hdr.SetFieldL(field2Str, str2);
THTTPHdrVal str3(value3Str);
hdr.SetFieldL(field3Str, str3);
THTTPHdrVal str4(value4Str);
hdr.SetFieldL(field4Str, str4);
THTTPHdrFieldIter it = hdr.Fields();
TInt count = 0;
while (it.AtEnd() == EFalse)
{
RStringTokenF nextTk = it();
RStringF nextStr = iStrP.StringF(nextTk);
THTTPHdrVal hVal;
TestL(hdr.GetField(nextStr,0,hVal)==KErrNone);
switch (count)
{
case 0:
TestL(nextStr.Index(RHTTPSession::GetTable()) == field1Str.Index(RHTTPSession::GetTable()));
break;
case 1:
TestL(nextStr.Index(RHTTPSession::GetTable()) == field2Str.Index(RHTTPSession::GetTable()));
break;
case 2:
TestL(nextStr.Index(RHTTPSession::GetTable()) == field3Str.Index(RHTTPSession::GetTable()));
break;
case 3:
TestL(nextStr.Index(RHTTPSession::GetTable()) == field4Str.Index(RHTTPSession::GetTable()));
break;
}
++it;
++count;
}
// Close strings used in this test
CleanupStack::PopAndDestroy(10);
}
void CPasswordTest::StartOnceADayPasswordTestL()
{
TestL(iPassWin->BaseWin()->PasswordWindow(EPasswordOnceADay)==KErrNone);
}
void CPasswordTest::PasswordMsgReceivedL()
{
TestL(iPassWin->BaseWin()->OrdinalPosition()==0);
if (iPassState==EWaitForSwitchOff3 || iPassState==EWaitForSwitchOff4)
Fail(3);
}
