// 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 <e32test.h>
#include <s32mem.h>
//
// 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<TEntry>* iCheat;
};
CTestStreamDictionary* CTestStreamDictionary::NewL()
{
CTestStreamDictionary* thing=new(ELeave) CTestStreamDictionary();
return thing;
}
CTestStreamDictionary::CTestStreamDictionary()
: iCheat((CArrayFixSeg<TEntry>*)&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 <class T1,class T2>
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<<anOriginal);
TEST2(r, KErrNone);
TRAP(r,out.CommitL());
TEST2(r, KErrNone);
//
// Read anOriginal in from the buffer.
//
RBufReadStream in(*buf);
TRAP(r,in>>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 ; i<origCount ; i++)
{
TEST(aOrig->Uid(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;
}