diff -r 000000000000 -r bde4ae8d615e os/textandloc/textrendering/texthandling/ttext/T_CONVS1.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/textandloc/textrendering/texthandling/ttext/T_CONVS1.CPP Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,290 @@ +/* +* Copyright (c) 1997-2010 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + + +#include +#include +#include +#include +#include +#include +#include "T_CONVS1.h" + +#define test(cond) \ + { \ + TBool __bb = (cond); \ + TEST(__bb); \ + if (!__bb) \ + { \ + ERR_PRINTF1(_L("ERROR: Test Failed")); \ + User::Leave(1); \ + } \ + } + +const TInt KTestCleanupStack=0x20; + +LOCAL_D CTrapCleanup* TheTrapCleanup; + +LOCAL_D TPtrC bigBuf(_L("This is a very big buffer indeed, containing text and special characters,\ + big enough to fill a segment of an editable text component that employs segmented storage")); + +//////////////////////////////////////////////////////////////////////////////////////////// +class TTestFieldFactoryCONVS1 : public MTextFieldFactory + { +public: + // from MTextFieldFactory + virtual CTextField* NewFieldL(TUid aFieldType); + // Creates a field of the type specified + // Returns NULL if it does not recognise/support the field type + }; + +CTextField* TTestFieldFactoryCONVS1::NewFieldL(TUid aFieldType) +// Creates a field (in aHeader) of the type specified in aHeader +// + { + CTextField* field=NULL; + if (aFieldType==KDateTimeFieldUid) + field = (CTextField*)new(ELeave) CDateTimeField(); + return field; + } +///////////////////////////////////////////////////////////////////////////////////////////// + +_LIT(KOutputFile, "c:\\etext\\t_convs1.tst"); +template +void CT_CONVS1::testStoreRestoreL(T& aCopy,const T& aOriginal) +// Test document persistance. +// + { + // set up the store + RFs theFs; + theFs.Connect(); + // + theFs.Delete(KOutputFile); + theFs.MkDirAll(KOutputFile); + CFileStore* theStore=CDirectFileStore::CreateL(theFs,KOutputFile,EFileRead|EFileWrite); + CleanupStack::PushL(theStore); + theStore->SetTypeL(KDirectFileStoreLayoutUid); + // + // store the original + TStreamId id(0); + TRAPD(ret,id=aOriginal.StoreL(*theStore)); + test(ret==KErrNone); + // + // restore into the copy + TRAP(ret,aCopy.RestoreL(*theStore,id)); + test(ret==KErrNone); + // + // tidy up + CleanupStack::PopAndDestroy(); // theStore + theFs.Close(); + } + +TInt CT_CONVS1::IsEqual(const CPlainText* aCopy,const CPlainText* aOriginal) +// +// Tests for equality of plain text components. +// Takes account of multiple segments of a segmented text component. +// + { + TInt lengthOfOriginal=aOriginal->DocumentLength(); + TInt lengthOfCopy=aCopy->DocumentLength(); + test(lengthOfOriginal==lengthOfCopy); +// + TPtrC copy,orig; +// + TInt lengthRead=0; + while(lengthRead<=lengthOfOriginal) + { + copy.Set((aCopy->Read(lengthRead))); + orig.Set((aOriginal->Read(lengthRead))); + for (TInt offset=0; offsetFieldCount(); + TInt origFieldCount=aOriginal->FieldCount(); + test(copyFieldCount==origFieldCount); + return 1; + } + + +TInt CT_CONVS1::DocsEqual(const CGlobalText* aCopy,const CGlobalText* aOrig) +// +// +// + { + test(IsEqual(aCopy,aOrig)); + return 1; + } + + +void CT_CONVS1::GenerateGlobalTextL() +// +// Create a global text documnet. +// + { +// Set up the character format layer. + CCharFormatLayer* cl1=CCharFormatLayer::NewL(); + TCharFormat charFormat; TCharFormatMask charMask; + charMask.ClearAll(); + charFormat.iFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold); charMask.SetAttrib(EAttFontStrokeWeight); + charFormat.iFontSpec.iFontStyle.SetPosture(EPostureItalic); charMask.SetAttrib(EAttFontPosture); + charFormat.iFontPresentation.iUnderline=EUnderlineOn; charMask.SetAttrib(EAttFontUnderline); + cl1->SetL(charFormat,charMask); + charMask.ClearAll(); +// Set up the paragraph format layer. + CParaFormatLayer* l1=CParaFormatLayer::NewL(); + CParaFormat* paraFormat=CParaFormat::NewL(); TParaFormatMask paraMask; + paraMask.ClearAll(); + TTabStop tab1,tab2; + tab1.iTwipsPosition=5000; tab2.iTwipsPosition=5001; + tab1.iType=TTabStop::ERightTab; tab2.iType=TTabStop::ECenteredTab; + paraFormat->StoreTabL(tab1); + paraFormat->StoreTabL(tab2); + paraMask.SetAttrib(EAttTabStop); + paraFormat->iLeftMarginInTwips=666; paraMask.SetAttrib(EAttLeftMargin); + l1->SetL(paraFormat,paraMask); + paraMask.ClearAll(); +// Now create the global text component. + CGlobalText* globalDoc=CGlobalText::NewL(l1,cl1,CEditableText::ESegmentedStorage); + globalDoc->InsertL(0,bigBuf); +// Now create the global text that will be the restored one. + CCharFormatLayer* cr1=CCharFormatLayer::NewL(); + TCharFormat ff;TCharFormatMask mm;cr1->SetL(ff,mm); + CParaFormatLayer* r1=CParaFormatLayer::NewL(); + TParaFormatMask nn; r1->SetL((CParaFormat*)NULL,nn); + CGlobalText* restoredDoc=CGlobalText::NewL(r1,cr1,CEditableText::ESegmentedStorage); +// Store a text field in the global text. + TTestFieldFactoryCONVS1 factory; + globalDoc->SetFieldFactory(&factory); + restoredDoc->SetFieldFactory(&factory); + CTextField* field=NULL; + TRAPD(ret, + field=factory.NewFieldL(KDateTimeFieldUid)); + test(ret==KErrNone); + TRAP(ret, + globalDoc->InsertFieldL(0,field,KDateTimeFieldUid)); + test(ret==KErrNone); +// And do the streaming/restore. + INFO_PRINTF1(_L("Storing global text with field record")); + INFO_PRINTF1(_L("Restoring global text")); + testStoreRestoreL(*restoredDoc,*globalDoc); + test(DocsEqual(restoredDoc,globalDoc)); +// Now clean up. + TInt restoredCharChain=cr1->ChainCount(); + TInt restoredParaChain=r1->ChainCount(); + CCharFormatLayer* chCurrent=cr1; + CCharFormatLayer* chNext=(CCharFormatLayer*)cr1->SenseBase(); + delete chCurrent; + for (TInt loop=0;loopSenseBase(); + delete chCurrent; + } + CParaFormatLayer* paCurrent=r1; + CParaFormatLayer* paNext=(CParaFormatLayer*)r1->SenseBase(); + delete paCurrent ; + for (TInt ploop=0;ploopSenseBase(); + delete paCurrent; + } + delete l1; + delete cl1; + delete paraFormat; + delete restoredDoc; + delete globalDoc; + } + + +void CT_CONVS1::setupCleanup() +// +// Initialise the cleanup stack. +// + { + + TheTrapCleanup=CTrapCleanup::New(); + TRAPD(r,\ + {\ + for (TInt i=KTestCleanupStack;i>0;i--)\ + CleanupStack::PushL((TAny*)1);\ + test(r==KErrNone);\ + CleanupStack::Pop(KTestCleanupStack);\ + }); + } + + +void CT_CONVS1::DeleteDataFile(const TDesC& aFullName) + { + RFs fsSession; + TInt err = fsSession.Connect(); + if(err == KErrNone) + { + TEntry entry; + if(fsSession.Entry(aFullName, entry) == KErrNone) + { + RDebug::Print(_L("Deleting \"%S\" file.\n"), &aFullName); + err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly); + if(err != KErrNone) + { + RDebug::Print(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName); + } + err = fsSession.Delete(aFullName); + if(err != KErrNone) + { + RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName); + } + } + fsSession.Close(); + } + else + { + RDebug::Print(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName); + } + } + +CT_CONVS1::CT_CONVS1() + { + SetTestStepName(KTestStep_T_CONVS1); + } + +TVerdict CT_CONVS1::doTestStepL() + { + SetTestStepResult(EFail); + + setupCleanup(); + __UHEAP_MARK; + + INFO_PRINTF1(_L("T_CONVS1 - GlobalText Persistence")); + INFO_PRINTF1(_L("Generate global text")); + INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-ETEXT-LEGACY-T_CONVS1-0001 ")); + TRAPD(error1, GenerateGlobalTextL()); + + __UHEAP_MARKEND; + DeleteDataFile(KOutputFile); //deletion of data files must be before call to End() - DEF047652 + delete TheTrapCleanup; + + if(error1 == KErrNone) + { + SetTestStepResult(EPass); + } + + return TestStepResult(); + }