void CTestLtsyPhbkWrite::WriteEntryL(TInt aIndex)
{
TRequestStatus status;
TBuf8<800> pbData; // Client reserved space for phonebook data
TInt ret;
_LIT16(KTel,"123456%03d");
_LIT16(KText,"TelNo %03d");
TBuf16<20> text(KTel), number(KText);
CPhoneBookBuffer* pbBuffer = new(ELeave) CPhoneBookBuffer(); // used to write phonebook data
CleanupStack::PushL(pbBuffer);
pbBuffer->Set(&pbData); // Set it to point to the Client buffer
pbBuffer->AddNewEntryTag();
// convert number into TLV format and append it to allocated buffer
TInt index = aIndex;
ret = pbBuffer->PutTagAndValue(RMobilePhoneBookStore::ETagPBAdnIndex,(TUint16)index);
if( ret != KErrNone )
{
CleanupStack::PopAndDestroy();
SetTestStepResult(EFail);
}
number.Format(KTel(), index);
ret=pbBuffer->PutTagAndValue(RMobilePhoneBookStore::ETagPBNumber, number);
// ret=pbBuffer->PutTagAndValue(RMobilePhoneBookStore::ETagPBNewEntry, number);
if( ret != KErrNone )
{
CleanupStack::PopAndDestroy();
SetTestStepResult(EFail);
}
// convert number type into TLV format and append it to allocated buffer
TUint8 tonNpi=KTypeOfNumber;
ret=pbBuffer->PutTagAndValue(RMobilePhoneBookStore::ETagPBTonNpi, tonNpi);
if(ret!=KErrNone)
{
CleanupStack::PopAndDestroy();
SetTestStepResult(EFail);
}
text.Format(KText(), index);
// convert text into TLV format and append it to allocated buffer
ret=pbBuffer->PutTagAndValue(RMobilePhoneBookStore::ETagPBText, text);
if(ret != KErrNone)
{
CleanupStack::PopAndDestroy();
SetTestStepResult(EFail);
}
PhoneBookStore().Write(status, pbData,index);
User::WaitForRequest(status);
TInt r=status.Int();
INFO_PRINTF2(_L("Write() request status = %d"),r);
CleanupStack::PopAndDestroy();
}
// Generation
// -----------------------------------------------------------------------------
// XIMPTestPresenceDataUtils::GenerateIdentityLC()
// -----------------------------------------------------------------------------
//
EXPORT_C CXIMPIdentityImp*
XIMPTestPresenceDataUtils::GenerateIdentityLC(
const TDesC8* aPrefix,
TPresenceDataGroup aGroup )
{
// According to Group:
// Generate uri
_LIT16( KUri, "http://google.com" );
// Generate protocolAddr
_LIT16( KProtocolAddress, "protocollll" );
CXIMPIdentityImp* pres = CXIMPIdentityImp::NewLC( KUri );
return pres;
}
int main()
{
__UHEAP_MARK;
_LIT16(Kname,"tbuf16tochar");
TBuf16<20>src(Kname);
wchar_t * des= NULL;
int size=50;
int retval =ESuccess;
retval= Tbuf16ToWchar(src,des,size);
if(retval == EInvalidPointer)
{
printf(" Test_tbuf16towchar_invalidpointer PASSED\n");
}
else
{
assert_failed = true;
printf(" Test_tbuf16towchar_invalidpointer FAILURE\n");
}
delete[] des;
des = NULL;
__UHEAP_MARKEND;
testResultXml("test_tbuf16towchar_nullcheck");
return 0;
}
int main()
{
__UHEAP_MARK;
{
int retval =ESuccess;
string str((const char*)"hihihihihihihihi");
_LIT16(KTxt, "hellohello");
HBufC16* buff = HBufC16::NewL(10);
*buff = KTxt;
CleanupStack::PushL(buff);
int size = 24;
retval = Hbufc16ToString(buff,str,size);
if (retval ==ESuccess)
{
printf("hbufc16tostring Passed");
}
else
{
assert_failed = true;
printf("hbufc16tostring failed");
}
CleanupStack::PopAndDestroy(1);
}
__UHEAP_MARKEND;
testResultXml("test_hbufc16tostring_positive");
return 0;
}
int main()
{
__UHEAP_MARK;
_LIT16(Kname,"\xAE");
TBuf16<20>src(Kname);
wchar_t * des= new wchar_t [30];
int size=50;
int retval =ESuccess;
retval= Tbuf16ToWchar(src,des,size);
if(retval ==ESuccess)
{
printf(" Test_tbuf16towchar_unicode PASSED\n");
}
else
{
assert_failed = true;
printf(" Test_tbuf16towchar_unicode FAILURE\n");
}
delete[] des;
des = NULL;
__UHEAP_MARKEND;
testResultXml("test_tbuf16towchar_unicode");
return 0;
}
// -----------------------------------------------------------------------------
// COMASuplWapListener::PrintHex
//
// -----------------------------------------------------------------------------
//
void COMASuplWapListener::PrintHex(const TDesC8& aBuffer,TInt aLine)
{
TBuf<256> buffer;
TBuf<2> buff;
_LIT16(KFormat1,"%02x");
TInt len = aBuffer.Length();
//The buffer is usually larger than what can be logged in a single line in the log file. As such this should only attempt
// to log 27 hex blocks to each log line.
const TInt KNumberOfBlocks = 27;
TInt blockNumber = KNumberOfBlocks;
for(TInt i = 0 ; i <len; i++)
{
//Check to see if the buffer should be logged and then emptied
if(i == blockNumber)
{
//Trace the buffer as it currently is
iTrace->Trace(buffer, KTraceFileName, aLine);
//Reset the buffer for the next log line
buffer.Zero();
blockNumber += KNumberOfBlocks;
}
buff.Zero();
buff.Format(KFormat1,aBuffer[i]);
buffer.Append(buff);
buffer.Append(_L(" "));
}
iTrace->Trace(buffer, KTraceFileName, aLine);
}
int main()
{
__UHEAP_MARK;
_LIT16(Kname,"tbuf16tochar");
TBuf16<20>src(Kname);
char * des= new char [20];
int size=10;
int retval =ESuccess;
retval= Tbuf16ToChar(src,des,size);
if(retval == EInvalidSize)
{
printf(" Test_tbuf16tochar_invalidsize PASSED\n");
}
else
{
assert_failed = true;
printf(" Test_tbuf16tochar_invalidsize FAILURE\n");
}
delete[] des;
des = NULL;
__UHEAP_MARKEND;
testResultXml("test_tbuf16tochar_invalidsize");
return 0;
}
TInt CFloggerTest012_01::DoHeapTestWrite()
{
_LIT16(KTestMessageOne,"TEST 12.04: Heap Test: The value of test integer variable :%d"); //unicode test decriptor
RFileLogger::WriteFormat(KStdSubsysTag8, KStdCompTag8, KTestMessageOne, 100);
return KErrNone;
}
/**
@SYMTestCaseID UIF-ETUL-0024
@SYMREQ DEF114388
@SYMTestCaseDesc Test of CTulAddressStringTokenizer::SearchPhoneNumberL( const TDesC& aText )
with all the phone number separators.
@SYMTestPriority Normal
@SYMTestStatus Implemented
@SYMTestActions There should be 5 phone numbers separators:
- KCharLinefeed = 0x000A
- KCharFormfeed = 0x000C
- KCharCarriageReturn = 0x000D
- KCharLineSeparator = 0x2028
- KCharParagraphSeparator = 0x2029
With a simple string _LIT16(KTestPhoneSeparator, "11111%c22222")
and with all the separators above, we apply the tested function:
CTulAddressStringTokenizer::SearchPhoneNumberL( const TDesC& aText )
@SYMTestExpectedResults On the 5 cases, the function should find 2 phone numbers
i.e: multiSearch->ItemCount() should be equal to 2
otherwise the test fail.
*/
void CT_AddressStringTokenizerStep::TestPhoneSearchSeparatorsL()
{
TInt KCharLinefeed = 0x000A;
TInt KCharFormfeed = 0x000C;
TInt KCharCarriageReturn = 0x000D;
TInt KCharLineSeparator = 0x2028;
TInt KCharParagraphSeparator = 0x2029;
TInt KSeparators[5]={KCharLinefeed,KCharFormfeed,KCharCarriageReturn,KCharLineSeparator,KCharParagraphSeparator};
_LIT16(KTestPhoneSeparator, "11111%c22222");
TBool succeed=ETrue;
TBuf16<16> str;
for (TInt k=0;k<5;k++)
{
str.Format(KTestPhoneSeparator,KSeparators[k]);
CTulAddressStringTokenizer* multiSearch = CTulAddressStringTokenizer::NewL(str,
CTulAddressStringTokenizer::EFindItemSearchPhoneNumberBin);
if (multiSearch->ItemCount()!=2)
{
succeed=EFalse;
}
delete multiSearch;
if (succeed==EFalse)
{
break;
}
}
TEST(succeed);
}
int main()
{
__UHEAP_MARK;
_LIT16(Kname,"");
TBuf16<3>src(Kname);
wchar_t * des= new wchar_t [3];
int size=3;
int retval =ESuccess;
retval= Tbuf16ToWchar(src,des,size);
if(retval == EDescriptorNoData)
{
printf(" Test_tbuf16towchar_nodata PASSED\n");
}
else
{
assert_failed = true;
printf(" Test_tbuf16towchar_nodata FAILURE\n");
}
delete[] des;
des = NULL;
__UHEAP_MARKEND;
testResultXml("test_tbuf16towchar_nodata");
return 0;
}
int main()
{
__UHEAP_MARK;
int retval =ESuccess;
wchar_t* mycharstring = new wchar_t[30];
_LIT16(KTxt, "");
HBufC16* buff = HBufC16::NewL(10);
*buff = KTxt;
CleanupStack::PushL(buff);
int size = 30;
retval = Hbufc16ToWchar(buff,mycharstring,size);
if (retval ==EDescriptorNoData)
{
printf("hbufc16towchar Passed");
}
else
{
assert_failed = true;
printf("hbufc16towchar failed");
}
CleanupStack::PopAndDestroy(1);
delete []mycharstring;
mycharstring = NULL;
__UHEAP_MARKEND;
testResultXml("test_hbufc16towchar_negative1");
return 0;
}
int main()
{
__UHEAP_MARK;
_LIT16(Kname,"helloaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
TBuf16<300>src(Kname);
char * des=new char[300];
int size=20000;
int retval =ESuccess;
retval= Tbufc16ToChar(src,des,size);
if(retval ==ESuccess)
{
printf(" Test_tbufc16tochar_maxsize PASSED\n");
}
else
{
assert_failed = true;
printf(" Test_tbufc16tochar_maxsize FAILURE\n");
}
delete[] des;
des = NULL;
__UHEAP_MARKEND;
testResultXml("test_tbufc16tochar_maxsize");
return 0;
}
int main()
{
__UHEAP_MARK;
_LIT16(Kname,"123");
TBuf <3>src;
src.Copy(Kname);
wchar_t * des= new wchar_t [4];
int size=4;
int retval =ESuccess;
retval= Tlitc16ToWchar(src,des,size);
if(retval ==ESuccess)
{
printf(" Test_tlit16towchar_minsize PASSED\n");
}
else
{
assert_failed = true;
printf(" Test_tlit16towchar_minsize FAILURE\n");
}
delete[] des;
des = NULL;
__UHEAP_MARKEND;
testResultXml("Test_tlit16towchar_minsize");
return 0;
}
void main()
{
__UHEAP_MARK;
_LIT16(Kname,"tbuf16tochar");
char * des= new char [20];
int size=50;
int retval =ESuccess;
int i=0;
while (i<=1000)
{
retval= Tlitc16ToChar(Kname,des,size);
i++;
printf("%d\n",i);
}
if(retval ==ESuccess)
{
printf(" Test_tlit16tochar_positive PASSED\n");
}
else
{
assert_failed = true;
printf(" Test_tlit16tochar_positive FAILURE\n");
}
delete[] des;
des = NULL;
__UHEAP_MARKEND;
testResultXml("test_tlit16tochar_positive");
}
int main()
{
__UHEAP_MARK;
{
_LIT16(Kname,"");
TBuf <20>src;
src.Copy(Kname);
string str;
//int size=10;
int retval =ESuccess;
retval= Tlit16ToString(src,str);
if(retval == EDescriptorNoData)
{
printf(" Testtlit16tostring PASSED\n");
}
else
{
assert_failed = true;
printf(" Testtlit16tostring FAILURE\n");
}
}
__UHEAP_MARKEND;
testResultXml("test_tlit16tostring_negative1");
return 0;
}
void CCSatSetUpCallFU::TestNotifySetUpCallPCmd0001bL()
{
OpenEtelServerL(EUseExtendedError);
CleanupStack::PushL(TCleanupItem(Cleanup,this));
OpenPhoneL();
OpenSatL();
RSat::TSetUpCallRspV2 resp;
RSat::TSetUpCallRspV2Pckg respPck(resp);
RSat::TSetUpCallV6 setupCallData;
const TUint8 KAddress = 0x91; //10010001
TData data;
data.iCommandNumber = 1;
data.iCommandQualifier = KSetUpCallIfNotCurrentlyBusy;
data.iSourceDevice = KSim;
data.iDestinationDevice = KNetwork;
data.iAddress = KAddress;
data.iCommandType = KSetUpCall;
//
// Expected Sequence 2.1 (SET UP CALL, two alpha identifiers)
//
data.iCallNumber.Append(0x10);
data.iCallNumber.Append(0x32);
data.iCallNumber.Append(0x04);
data.iCallNumber.Append(0x21);
data.iCallNumber.Append(0x43);
data.iCallNumber.Append(0x65);
data.iCallNumber.Append(0x1C);
data.iCallNumber.Append(0x2C);
_LIT8(KAlphaIdentifier8_1, "CONFIRMATION");
_LIT16(KAlphaIdentifier16, "CONFIRMATION");
_LIT8(KAlphaIdentifier8_2, "CALL");
data.iDuration.iIfUse = EFalse;
data.iCommandQualifier = KSetUpCallIfNotCurrentlyBusy;
ProactiveCommandCallL( setupCallData, data, KAlphaIdentifier8_1, KErrNone, KAlphaIdentifier8_2 );
DataCompareL(setupCallData,
data.iCommandQualifier,
KAlphaIdentifier16,
RSat::EInternationalNumber,
RSat::EIsdnNumberPlan);
resp.iInfoType = RSat::KNoAdditionalInfo;
resp.iAdditionalInfo.Zero();
resp.iGeneralResult = RSat::KSuccess;
CCSatComponentTestBase::GenerateTerminalResponseL( data.iCommandNumber, data.iCommandType,
data.iCommandQualifier, RSat::ESetUpCall, respPck, KNullDesC16, resp.iGeneralResult );
AssertMockLtsyStatusL();
CleanupStack::PopAndDestroy(1, this); // this
}
/**
@SYMTestCaseID SYSLIB-CHARCONV-UT-4020
@SYMTestCaseDesc Convert out of range characters from foreign character set to Unicode
@SYMTestPriority High
@SYMTestActions Test for ConvertToUnicode() for some out of range foreign characters 0x80 - 0xFF
@SYMTestExpectedResults Test must not fail
@SYMPREQ PREQ22265
@SYMREQ REQ10670
*/
void CT_TURKISHLOCKING::ConvertOutOfRangeForeignCharacters()
{
//test foreign chararcter point which is not in the scope, e.g. 0x80 in GSM03.38, which should always mapped to 0xFFFD
INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-UT-4020 Testing Characters not in the Scope "));
generatedForeign.SetLength(1);
generatedForeign[0] = 0x80;
TInt state=CCnvCharacterSetConverter::KStateDefault;
_LIT16(KExpected2, "\xfffd"); //the expected foreign
test( 0 == characterSetConverter->ConvertToUnicode(generatedUnicode, generatedForeign, state));
test( generatedUnicode == KExpected2 );
}
TInt CFloggerTest012_02::DoTestWrite()
{
//unicode test decriptor
_LIT16(KTestMessageTwo,"TEST 12.02: The value of first test integer variable :%d The value of second test integer variable : %d");
RFileLogger ::WriteFormat(KStdSubsysTag8, KStdCompTag8, KTestMessageTwo, 100, 200);
return KErrNone;
}
TVerdict CSysUtilsGetLangSWVersionNoNewLinesStep::doTestStepL()
{
TInt err = SetTestPath(ETrue);
if( err != KErrNone )
{
ERR_PRINTF2(_L("Could not turn test path on. Error = %d"), err);
SetTestStepResult(EAbort);
return TestStepResult();
}
INFO_PRINTF1(_L("Test path turned on."));
err = DeletePSProperties();
if( err != KErrNone )
{
ERR_PRINTF2(_L("Could not delete P&S properties. Error = %d"), err);
SetTestStepResult(EAbort);
return TestStepResult();
}
INFO_PRINTF1(_L("Deleted P&S properties successfully."));
_LIT16(KDummy,"xxxxx");
TBuf16<KSysUtilVersionTextLength> version;
version.Insert(0,KDummy);
err = SysUtil::GetLangSWVersion( version );
if ( err == KErrNone)
{
_LIT(KLangSw, "LangSW");
TPtrC16 line;
TESTL( GetStringFromConfig(ConfigSection(), KLangSw, line) );
TBuf16<KSysUtilVersionTextLength> testBuf(line);
if (version.Compare(testBuf)==0)
{
INFO_PRINTF1(_L("Got version "));
INFO_PRINTF1(version);
}
else
{
ERR_PRINTF1(_L("Version not correct"));
INFO_PRINTF1(version);
SetTestStepResult(EFail);
}
}
else
{
ERR_PRINTF2(_L("Error code = %d"), err);
SetTestStepResult(EFail);
}
return TestStepResult();
}
TInt CFloggerTest012_01::DoTestWrite()
{
_LIT16(KTestMessageOne,"TEST 12.01: The value of test integer variable :%d"); //unicode test decriptor
RFileLogger::WriteFormat(KStdSubsysTag8, KStdCompTag8, KTestMessageOne, 100);
// connect so we can flush file buffer for heap check
RFileLogger theFlogger;
theFlogger.Connect();
theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
ForceLogFlush(theFlogger);
theFlogger.Close();
return KErrNone;
}
/*
@SYMTestCaseID GRAPHICS-FREETYPE-0001
@SYMTestCaseDesc Supplementary characters rasterization Test
@SYMTestPriority High
@SYMTestActions This test checks that the free type rasterizer rasterizes supplementary characters
properly.
It prints the descriptor containing supplementary characters with 2 Fonts. One font does not support
supplementary characters and the other does.
@SYMTestExpectedResults This step should be executed without error and the user should be able to see the
above descriptor is displayed as a square with the first font and in the correct shape with the other font.
@SYMDEF DEF120018 Security issue in FreeType rasterizer! Supplementary characters rendered as BMP
*/
void CTestHarness::SurrogateRasterizedTestsL()
{
// The literal descriptor consisting of common letter 'A' and Supplementary character 0x20000
// which is represented by surrogate pair 0xD840 0xDC00
_LIT16(KSurrogatePairCode, "A\xD840\xDC00");
// Testing Fonts: DejaVu Sans Condensed does not support Supplementary character.
// Test2 only supports letter "A" and Supplementary character 0x20000
TFontSpec fsDejaVuSans(_L("DejaVu Sans Condensed"), 16 * 20);
TFontSpec fsTest2(_L("Test2"), 16 * 20);
Clear();
// Prints test descriptor with font SwissA
iTestFont = NULL;
TInt error = iDev->GetNearestFontToDesignHeightInTwips((CFont*&)iTestFont,fsDejaVuSans);
iStep->TESTL(KErrNone == error);
if (!iTestFont->IsOpenFont())
{
iDev->ReleaseFont(iTestFont);
iTestFont = NULL;
User::Leave(KErrGeneral);
}
PrintMetrics(EFalse);
UseFont(iTestFont);
Print(KSurrogatePairCode);
iDev->ReleaseFont(iTestFont);
// Prints test descriptor with font Test2
iTestFont = NULL;
error = iDev->GetNearestFontToDesignHeightInTwips((CFont*&)iTestFont,fsTest2);
iStep->TESTL(KErrNone == error);
if (!iTestFont->IsOpenFont())
{
iDev->ReleaseFont(iTestFont);
iTestFont = NULL;
User::Leave(KErrGeneral);
}
PrintMetrics(EFalse);
UseFont(iTestFont);
Print(KSurrogatePairCode);
iDev->ReleaseFont(iTestFont);
iTestFont = NULL;
// User::After(10000000);
}
TInt TMD5Checker::CheckFileL(class RFs& aFs, const TDesC& aFile, const TDesC16& aHash)
{
TInt ret = ReadAndHashFileL(aFs, aFile);
_LIT16(KMd5Prefix, "md5:");
TInt offset = 0;
if(aHash.Left(KMd5Prefix().Length()).CompareF(KMd5Prefix) == 0){
offset = KMd5Prefix().Length();
}
for(TUint i = 0; i < sizeof(m_hex_md5_checksum) && ret == KErrNone; ++i){
ret = (aHash[i+offset] == m_hex_md5_checksum[i]) ? KErrNone :KMd5NoMatch;
}
return ret;
}
void CSendAsSender::SendMessageL(const RMessage2 aMessage, TBool aHasCapability)
{
__ASSERT_ALWAYS( iState == ESenderIdle, User::Invariant() );
__ASSERT_ALWAYS( iClientMtm != NULL, User::Invariant() );
iState = ESenderAuthoriseSend;
// Serialise the recipient list
const CMsvRecipientList& rcptList = iClientMtm->AddresseeList();
const MDesC16Array& recipient = rcptList.RecipientList();
TInt rcptCount = recipient.MdcaCount();
TInt size = 0;
for(TInt i=0;i<rcptCount; ++i)
{
size += recipient.MdcaPoint(i).Length();
}
_LIT16(KComma, ",");
RBuf16 buffer;
buffer.CreateL(size+ rcptCount);
CleanupClosePushL(buffer);
if(rcptCount > 0)
{
buffer.Append(recipient.MdcaPoint(0));
}
for(TInt i=1;i<rcptCount; ++i)
{
buffer.Append(KComma);
buffer.Append(recipient.MdcaPoint(i));
}
RThread clientThread;
aMessage.Client(clientThread);
// Connect to UPS service.....
User::LeaveIfError(iUpsSession.Connect());
User::LeaveIfError(iUpsSubsession.Initialise(iUpsSession, clientThread));
iDecision = EUpsDecNo;
iUpsSubsession.Authorise(aHasCapability, KUidSendAs2Service, buffer, iDecision, iStatus);
SetActive();
CleanupStack::PopAndDestroy(&buffer);
}
/**
@SYMTestCaseID SYSLIB-BAFL-CT-4022
@SYMREQ REQ8170
@SYMDEF DEF141094
@SYMTestCaseDesc GetVersionInsufficientBuffer
@SYMTestPriority HIGH
@SYMTestStatus Implemented
@SYMTestActions Use the SysUtil::GetSWVersion method with its descriptor
@SYMTestActions parameter’s size smaller than the length of the software version text
@SYMTestActions Repeat for SysUtil::GetLangSWVersion
@SYMTestExpectedResults KErrTooBig is returned because not all the software version text can
@SYMTestExpectedResults be read into the buffer supplied.
*/
TVerdict CSysUtilsGetVersionInsufficienBufferStep::doTestStepL()
{
TInt err=KErrNone;
const TInt bufSize = 6;
_LIT16(kDummy,"xxxxx");
TBuf16<bufSize> version;
version.Insert(0,kDummy);
err = SysUtil::GetSWVersion( version );
ProcessError(err);
err = SysUtil::GetLangSWVersion( version );
ProcessError(err);
err = SysUtil::GetPRInformation( version );
ProcessError(err);
return TestStepResult();
}
void CSdlAppUi::AddCmdLineParamsL(CDesC8Array& aArgs)
{
_LIT8(KAddonParam, "--addondir=?:\\uqm-addons");
_LIT16(KTestFolder, "?:\\uqm-addons");
RFs fs;
fs.Connect();
for (TInt8 c = 'e'; c < 'z'; ++c)
{
TBuf16<32> buf(KTestFolder);
buf[0] = c;
if (BaflUtils::FolderExists(fs, buf))
{
TBuf8<32> arg(KAddonParam);
arg[11] = c;
aArgs.AppendL(arg);
break;
}
}
fs.Close();
}
int main()
{
//int count = 2;
bool err = false;
__UHEAP_MARK;
__UHEAP_FAILNEXT(2);
while(!err)
{
int retval =ESuccess;
char* myChar = new char[30];
_LIT16(KTxt, "hellohello");
TBufC16<30> buf(KTxt);
TPtrC src = buf.Des();
int size = 30;
retval = Tptrc16ToCharp(src,myChar,size);
if (retval ==EInsufficientSystemMemory)
{
printf("tptrc16tochar_reliability Passed\n");
err = true;
//Logging to some file can be done here
}
else
{
assert_failed = true;
printf("tptrc16tochar_reliability Failed\n");
//Logging to some file can be done here
}
delete[] myChar;
}
__UHEAP_MARKEND;
__UHEAP_RESET;
testResultXml("test_tptrc16tochar_reliability");
return 0;
}
TVerdict CSysUtilsGetLangSWVersionUnreadableStep::doTestStepL()
{
TInt err = SetTestPath(ETrue);
if( err != KErrNone )
{
ERR_PRINTF2(_L("Could not turn test path on. Error = %d"), err);
SetTestStepResult(EAbort);
return TestStepResult();
}
INFO_PRINTF1(_L("Test path turned on."));
err = DeletePSProperties();
if( err != KErrNone )
{
ERR_PRINTF2(_L("Could not delete P&S properties. Error = %d"), err);
SetTestStepResult(EAbort);
return TestStepResult();
}
INFO_PRINTF1(_L("Deleted P&S properties successfully."));
_LIT16(KDummy,"xxxxx");
TBuf16<KSysUtilVersionTextLength> version;
version.Insert(0,KDummy);
err = SysUtil::GetLangSWVersion( version );
if ( err == KErrCorrupt)
{
INFO_PRINTF1(_L("KErrCorrupt returned this is expected"));
}
else
{
ERR_PRINTF2(_L("Other error code = %d"), err);
SetTestStepResult(EFail);
}
return TestStepResult();
}
int main()
{
_LIT16(Kname,"tbuf16tochar");
//int count = 2;
bool err = false;
__UHEAP_MARK;
__UHEAP_FAILNEXT(2);
while(!err)
{
int retval =ESuccess;
char* myChar = new char[40];
int size =40;
retval = Tlitc16ToChar(Kname,myChar,size);
if (retval ==EInsufficientSystemMemory)
{
printf("tlit16tochar_reliability Passed\n");
err = true;
//Logging to some file can be done here
}
else
{
assert_failed = true;
err = true;
printf("tlit16tochar_reliability Failed\n");
//Logging to some file can be done here
}
delete[] myChar;
}
__UHEAP_MARKEND;
__UHEAP_RESET;
testResultXml("test_tlit16tochar_reliability");
return 0;
}
int main()
{
__UHEAP_MARK;
{
int retval =ESuccess;
string str((const char*)"");
_LIT16(KTxt, "hellohellohellohellohellohellohehellohellohehelloh");
TBuf16<300> tbuf(KTxt);
retval = Tbuf16ToString(tbuf,str);
if (retval ==ESuccess)
{
printf("tbuf16tostring Passed");
}
else
{
assert_failed = true;
printf("tbuf16tostring failed");
}
}
__UHEAP_MARKEND;
testResultXml("test_tbuf16tostring_boundary1");
return 0;
}
int main()
{
__UHEAP_MARK;
{
int retval =ESuccess;
wstring str;
_LIT16(KTxt, "");
TBuf<30> tbuf(KTxt);
retval = Tbuf16ToWstring(tbuf,str);
if (retval ==EDescriptorNoData)
{
printf("tbuf16towstring Passed");
}
else
{
assert_failed = true;
printf("tbuf16towstring failed");
}
}
__UHEAP_MARKEND;
testResultXml("test_tbuf16towstring_negative1");
return 0;
}
