diff -r 000000000000 -r bde4ae8d615e os/persistentdata/persistentstorage/store/TSTOR/t_stordict.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/persistentdata/persistentstorage/store/TSTOR/t_stordict.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,297 @@ +// Copyright (c) 1998-2009 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 + +// +// CTestStreamDictionary +// The only reason this class to be used here is to +// get an access to CStreamDictionary::iArray (private data member). +// +class CTestStreamDictionary : public CStreamDictionary + { +public: + struct TEntry + { + TUid uid; + TStreamId id; + }; +public: + static CTestStreamDictionary* NewL(); + CTestStreamDictionary(); + TUid Uid(TInt aInt) + { + return (*iCheat)[aInt].uid; + } + TStreamId StreamId(TInt aInt) + { + return (*iCheat)[aInt].id; + } + TInt Count() + { + return iCheat->Count(); + } +private: + CArrayFixSeg* iCheat; + }; + +CTestStreamDictionary* CTestStreamDictionary::NewL() + { + CTestStreamDictionary* thing=new(ELeave) CTestStreamDictionary(); + return thing; + } + +CTestStreamDictionary::CTestStreamDictionary() + : iCheat((CArrayFixSeg*)&iCheat-1) //Now iCheat points to the base class' private data member: + //CStreamDictionary::iArray. + //This way it is possible to call iArray's methods (even though it is private). + { + } + + +// +// Test code +// + +const TInt KTestExpandSize=0x20; + +static RTest TheTest(_L("t_stordict")); + +// some uid-stream pairs to use for testing +const TUid testUid1={1}; +static TStreamId testStreamId1=TStreamId(1); +// +const TUid testUid2={57}; +static TStreamId testStreamId2=TStreamId(57); +// +const TUid testUid3={99999}; +static TStreamId testStreamId3=TStreamId(425); +// + +//Put test data files to be deleted at the end here! +void DeleteDataFiles() + { + } + +//Tests macros and functions. +//If (!aValue) then the test will be panicked, the test data files will be deleted. +static void Check(TInt aValue, TInt aLine) + { + if(!aValue) + { + DeleteDataFiles(); + TheTest(EFalse, aLine); + } + } +//If (aValue != aExpected) then the test will be panicked, the test data files will be deleted. +static void Check(TInt aValue, TInt aExpected, TInt aLine) + { + if(aValue != aExpected) + { + RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue); + DeleteDataFiles(); + TheTest(EFalse, aLine); + } + } +//Use these to test conditions. +#define TEST(arg) ::Check((arg), __LINE__) +#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__) + +/** +@SYMTestCaseID SYSLIB-STORE-CT-1201 +@SYMTestCaseDesc Tests for copy operations on dictionary files +@SYMTestPriority High +@SYMTestActions Attempt for copying two classes using memory based streams. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +template +void testCopyL(T1& aCopy,const T2& anOriginal) + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1201 ")); + CBufSeg* buf=0; + TRAPD(r,buf=CBufSeg::NewL(KTestExpandSize)); + TEST2(r, KErrNone); +// +// Write anOriginal out to the buffer. +// + RBufWriteStream out; + out.Append(*buf); + TRAP(r,out<>aCopy); + TEST2(r, KErrNone); +// +// See if it's consumed the lot. +// + TUint8 b; + TEST2(in.Source()->ReadL(&b,1), 0); +// + delete buf; + } + +/** +@SYMTestCaseID SYSLIB-STORE-CT-1202 +@SYMTestCaseDesc Tests if two dictionary files are equal +@SYMTestPriority High +@SYMTestActions Tests if count of entries,UID and streamID's are equal +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +void testIsEqual(CTestStreamDictionary* aCopy,CTestStreamDictionary* aOrig) + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1202 ")); + TInt origCount=aOrig->Count(); + TEST(origCount==aCopy->Count()); + // + for (TInt i=0 ; iUid(i)==aCopy->Uid(i)); + TEST(aOrig->StreamId(i)==aCopy->StreamId(i)); + } + } + +/** +@SYMTestCaseID SYSLIB-STORE-CT-1203 +@SYMTestCaseDesc Tests for simple operations on a dictionary file +@SYMTestPriority High +@SYMTestActions Tests for assign,re-assigning,removing entries from the file +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void simpleTestsL() + { + CTestStreamDictionary* dic=CTestStreamDictionary::NewL(); + // attempt finding and removing with an empty dictionary + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1203 Manipulating an empty dictionary ")); + TEST2(dic->Count(), 0); + TEST(dic->At(testUid1)==KNullStreamId); + dic->Remove(testUid1); + TEST2(dic->Count(), 0); + TEST(dic->IsNull()); + // + // assign an entry + TheTest.Next(_L("Assigning entries and manipulating them")); + TRAPD(ret,dic->AssignL(testUid1,testStreamId1)); + TEST2(ret, KErrNone); + TEST2(dic->Count(), 1); + TEST(!dic->IsNull()); + TEST(dic->At(testUid1)==testStreamId1); + // + // assign another entry + TRAP(ret,dic->AssignL(testUid2,testStreamId2)); + TEST2(ret, KErrNone); + TEST2(dic->Count(), 2); + TEST(dic->At(testUid2)==testStreamId2); + // + // re-assign uid1 + TRAP(ret,dic->AssignL(testUid1,testStreamId3)); + TEST2(ret, KErrNone); + TEST2(dic->Count(), 2); + TEST(dic->At(testUid1)==testStreamId3); + // + // test finding and removing a non-existant entry from a non-empty dictionary + TEST(dic->At(testUid3)==KNullStreamId); + dic->Remove(testUid3); + TEST2(dic->Count(), 2); + // + // test removing an entry + dic->Remove(testUid1); + TEST2(dic->Count(), 1); + TEST(dic->At(testUid1)==KNullStreamId); + TEST(dic->At(testUid2)==testStreamId2); + TEST(!dic->IsNull()); + // + // test removing the other entry + dic->Remove(testUid2); + TEST2(dic->Count(), 0); + TEST(dic->IsNull()); + TEST(dic->At(testUid1)==KNullStreamId); + TEST(dic->At(testUid2)==KNullStreamId); + // + delete dic; + } + +/** +@SYMTestCaseID SYSLIB-STORE-CT-1204 +@SYMTestCaseDesc Streaming dictionary files tests +@SYMTestPriority High +@SYMTestActions Tests for copying an empty dictionary and dictionary containing different sets of entries + Tests for equality of two dictionary files and test the copied file. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void streamingTestsL() + { + CTestStreamDictionary* orig=CTestStreamDictionary::NewL(); + CTestStreamDictionary* copy=CTestStreamDictionary::NewL(); + // + // copy an empty dictionary + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1204 Streaming an empty dictionary ")); + TEST(orig->IsNull()); + testCopyL(*copy,*orig); + TEST(copy->IsNull()); + // + // copy a dictionary containing a range of entries + TheTest.Next(_L("Streaming a dictionary containing entries")); + TRAPD(ret,orig->AssignL(testUid1,testStreamId1)); + TRAP(ret,orig->AssignL(testUid2,testStreamId2)); + TRAP(ret,orig->AssignL(testUid3,testStreamId3)); + testCopyL(*copy,*orig); + testIsEqual(copy,orig); + TEST(!copy->IsNull()); + // + delete orig; + delete copy; + } + +void DoTestL() + { + simpleTestsL(); + streamingTestsL(); + } + +TInt E32Main() + { + __UHEAP_MARK; + + TheTest.Title(); + + CTrapCleanup* trapCleanup = CTrapCleanup::New(); + TheTest(trapCleanup != NULL); + + TheTest.Start(_L("Testing CStreamDictionary...")); + + TRAPD(err, DoTestL()); + TEST2(err, KErrNone); + + DeleteDataFiles(); + + TheTest.End(); + TheTest.Close(); + + delete trapCleanup; + + __UHEAP_MARKEND; + + return KErrNone; + } +