Symaptic: os/persistentdata/persistentstorage/store/TSTOR/t

     1 // Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    16 #include <s32file.h>

    17 #include <e32test.h>

    19 const TInt KTestCleanupStack=0x20;

    21 // This is a path specification and should not be used as is

    22 _LIT(KFileLocationSpec, "Z:\\STOR-TST\\T_SHAPE.DAT");

    24 class CShape;

    25 enum TShape {ENotAShape,ESquare,ECircle};

    26 typedef CShape* (*TShapeCtor)();

    27 class CShape : public CBase

    28 	{

    29 public:

    30 	static TShapeCtor Ctor(TShape type);

    31 //

    32 	virtual void ExternalizeL(RWriteStream& aStream) const=0;

    33 	virtual void InternalizeL(RReadStream& aStream)=0;

    34 //

    35 	TStreamId StoreL(CStreamStore& aStore) const;

    36 	void RestoreL(const CStreamStore& aStore,TStreamId anId);

    37 //

    38 	virtual TPtrC Name() const=0;

    39 	virtual TSize Extent() const=0;

    40 	virtual TPoint Centre() const=0;

    41 	};

    42 class CSquare : public CShape

    43 	{

    44 public:

    45 	static CShape* New();

    46 	CSquare() {}

    47 	CSquare(const TPoint& aCentre,TInt aSide);

    48 	void ExternalizeL(RWriteStream& aStream) const;

    49 	void InternalizeL(RReadStream& aStream);

    50 	TPtrC Name() const;

    51 	TSize Extent() const;

    52 	TPoint Centre() const;

    53 private:

    54 	TRect iRect;

    55 	};

    56 class CCircle : public CShape

    57 	{

    58 public:

    59 	static CShape* New();

    60 	CCircle() {}

    61 	CCircle(const TPoint& aCentre,TInt aRadius);

    62 	void ExternalizeL(RWriteStream& aStream) const;

    63 	void InternalizeL(RReadStream& aStream);

    64 	TPtrC Name() const;

    65 	TSize Extent() const;

    66 	TPoint Centre() const;

    67 private:

    68 	TPoint iCentre;

    69 	TInt iRadius;

    70 	};

    72 class TShapeHolder

    73 	{

    74 public:

    75 	TShapeHolder();

    76 	TShapeHolder(TShape aType,CShape* aShape);

    77 //

    78 	void ExternalizeL(RWriteStream& aStream) const;

    79 	void InternalizeL(RReadStream& aStream);

    80 	void StoreComponentsL(CStreamStore& aStore,CStoreMap& aMap) const;

    81 	void RestoreComponentsL(const CStreamStore& aStore);

    82 //

    83 	void ExternalizeSerialL(RWriteStream& aStream) const;

    84 	void InternalizeSerialL(RReadStream& aStream);

    85 //

    86 	TStreamId StoreL(CStreamStore& aStore) const;

    87 	void RestoreL(const CStreamStore& aStore,TStreamId anId);

    88 //

    89 	CShape* Shape() const;

    90 private:

    91 	TShape iType;

    92 	TSwizzle<CShape> iShape;

    93 	};

    95 LOCAL_D RTest test(_L("t_storshape"));

    96 LOCAL_D CTrapCleanup* TheTrapCleanup;

    97 LOCAL_D RFs TheFs;

    98 //LOCAL_D CBufStore* TheStore;

    99 LOCAL_D CFileStore* TheStore;

   100 LOCAL_D RStoreWriteStream TheSink;

   101 LOCAL_D RStoreReadStream TheSource;

   102 //LOCAL_D RFileWriteStream TheSink;

   103 //LOCAL_D RFileReadStream TheSource;

   105 /**

   106 @SYMTestCaseID          PDS-STORE-CT-4025

   107 @SYMTestCaseDesc	    Basic test for CStoreMap Forget() and Unbind() API

   108 @SYMTestPriority 	    High

   109 @SYMTestActions  	    Unbind stream from Map, forget sgtream from map

   110 @SYMTestExpectedResults map stream ID should be NUll

   111 @SYMDEF                 DEF135804

   112 */

   113 LOCAL_C void testExtraStoreMapAPIsL()

   114 	{

   115 	test.Next(_L("@SYMTestCaseID PDS-STORE-CT-4025"));

   116 	CShape* shape=new(ELeave) CCircle(TPoint(70,80),40);

   117 	CleanupStack::PushL(shape);

   118 	CStoreMap* map=CStoreMap::NewLC(*TheStore);

   119 	TStreamId id = shape->StoreL(*TheStore);

   121 	map->BindL(shape,id);

   122 	test(id == map->At(shape));

   123 	//Unbind the twizzle(shape) and test to make sure it is unbinded

   124 	map->Unbind(shape);

   125 	test(KNullStreamId == map->At(shape));

   127 	map->BindL(shape,id);

   128 	test(shape == map->Label(id));

   129 	//Forget the stream id and test to make sure it is forgotten

   130 	map->Forget(id);

   131 	test(shape != map->Label(id));

   132 	CleanupStack::PopAndDestroy(2,shape);

   133 	}

   134 /**

   135 @SYMTestCaseID          SYSLIB-STORE-CT-1200

   136 @SYMTestCaseDesc	    Shape streaming test

   137 @SYMTestPriority 	    High

   138 @SYMTestActions  	    Attempt for streaming of different shapes

   139 @SYMTestExpectedResults Test must not fail

   140 @SYMREQ                 REQ0000

   141 */

   142 LOCAL_C void testShapesL()

   143     {

   144 	test.Start(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1200 Shape streaming "));

   146 	TParsePtrC parse(KFileLocationSpec);

   147 //

   148 //	TheStore=CDirectFileStore::ReplaceLC(TheFs,KTestFile,EFileRead|EFileWrite);

   149 	TheStore=CPermanentFileStore::ReplaceLC(TheFs,parse.NameAndExt(),EFileRead|EFileWrite);

   150 	TheStore->SetTypeL(TheStore->Layout());

   151 //

   152 	RStoreWriteStream snk;

   153 	TStreamId id=snk.CreateL(*TheStore);

   154 	TShapeHolder hldr(ESquare,new(ELeave) CSquare(TPoint(20,30),40));

   155 	hldr.ExternalizeSerialL(snk);

   156 	delete hldr.Shape();

   157 	hldr=TShapeHolder(ECircle,new(ELeave) CCircle(TPoint(70,80),40));

   158 	hldr.ExternalizeSerialL(snk);

   159 	delete hldr.Shape();

   160 	snk.Close();

   161 	RStoreReadStream src;

   162 	src.OpenL(*TheStore,id);

   163 	hldr.InternalizeSerialL(src);

   164 	delete hldr.Shape();

   165 	hldr.InternalizeSerialL(src);

   166 	delete hldr.Shape();

   167 	src.Close();

   168 //

   169 	hldr=TShapeHolder(ESquare,new(ELeave) CSquare(TPoint(20,30),40));

   170 	id=hldr.StoreL(*TheStore);

   171 	delete hldr.Shape();

   172 	hldr.RestoreL(*TheStore,id);

   173 	delete hldr.Shape();

   174 //

   175 	CShape* shape=new(ELeave) CCircle(TPoint(70,80),40);

   176 	CStoreMap* map=CStoreMap::NewL(*TheStore);

   177 	TStreamId id2 = shape->StoreL(*TheStore);

   179 	testExtraStoreMapAPIsL();

   181 	map->BindL(shape,id2);

   182 	snk=RStoreWriteStream(*map);

   183 	id=snk.CreateL(*TheStore);

   184 	snk<<shape;

   185 	snk.Close();

   186 	delete shape;

   187 	src.OpenL(*TheStore,id);

   188 	src>>id;

   189 	src.Close();

   190 	shape=new(ELeave) CCircle;

   191 	shape->RestoreL(*TheStore,id);

   192 	delete map;

   193 	TRAPD(r,shape->RestoreL(*TheStore,id));

   194 	test(r==KErrNotFound);

   195 	delete shape;

   196 //

   197 	CleanupStack::PopAndDestroy();

   198     }

   200 //

   201 // Prepare the test directory.

   202 //

   203 LOCAL_C void setupTestDirectory()

   204     {

   205 	TInt r=TheFs.Connect();

   206 	test(r==KErrNone);

   207 //

   208 	TDriveUnit drive(static_cast<TUint>(RFs::GetSystemDrive()));

   209 	TParse parse;

   210 	parse.Set(drive.Name(), &KFileLocationSpec, NULL);

   212 	r=TheFs.MkDir(parse.DriveAndPath());

   213 	test(r==KErrNone||r==KErrAlreadyExists);

   214 	r=TheFs.SetSessionPath(parse.DriveAndPath());

   215 	test(r==KErrNone);

   216 	}

   218 //

   219 // Initialise the cleanup stack.

   220 //

   221 LOCAL_C void setupCleanup()

   222     {

   223 	TheTrapCleanup=CTrapCleanup::New();

   224 	test(TheTrapCleanup!=NULL);

   225 	TRAPD(r,\

   226 		{\

   227 		for (TInt i=KTestCleanupStack;i>0;i--)\

   228 			CleanupStack::PushL((TAny*)1);\

   229 		test(r==KErrNone);\

   230 		CleanupStack::Pop(KTestCleanupStack);\

   231 		});

   232 	test(r==KErrNone);

   233 	}

   235 LOCAL_C void DeleteDataFile(const TDesC& aFullName)

   236 	{

   237 	RFs fsSession;

   238 	TInt err = fsSession.Connect();

   239 	if(err == KErrNone)

   240 		{

   241 		TEntry entry;

   242 		if(fsSession.Entry(aFullName, entry) == KErrNone)

   243 			{

   244 			RDebug::Print(_L("Deleting \"%S\" file.\n"), &aFullName);

   245 			err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);

   246 			if(err != KErrNone)

   247 				{

   248 				RDebug::Print(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);

   249 				}

   250 			err = fsSession.Delete(aFullName);

   251 			if(err != KErrNone)

   252 				{

   253 				RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);

   254 				}

   255 			}

   256 		fsSession.Close();

   257 		}

   258 	else

   259 		{

   260 		RDebug::Print(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);

   261 		}

   262 	}

   264 //

   265 // Test the streaming framework.

   266 //

   267 GLDEF_C TInt E32Main()

   268     {

   269 	test.Title();

   270 	setupTestDirectory();

   271 	setupCleanup();

   272 	__UHEAP_MARK;

   273 //

   274 	TRAPD(r,testShapesL());

   275 	test(r==KErrNone);

   277 	//deletion of data files must be before call to .End() - DEF047652

   278 	TDriveUnit drive(static_cast<TUint>(RFs::GetSystemDrive()));

   279 	TParse parse;

   280 	parse.Set(drive.Name(), &KFileLocationSpec, NULL);

   281 	::DeleteDataFile(parse.FullName());

   283 	test.End();

   284 //

   285 	__UHEAP_MARKEND;

   287 	delete TheTrapCleanup;

   288 	TheFs.Close();

   289 	test.Close();

   290 	return 0;

   291     }

   293 TShapeCtor CShape::Ctor(TShape type)

   294 	{

   295 	switch (type)

   296 		{

   297 	case ESquare:

   298 		return &CSquare::New;

   299 	case ECircle:

   300 		return &CCircle::New;

   301 	default:

   302 		return NULL;

   303 		}

   304 	}

   306 TStreamId CShape::StoreL(CStreamStore& aStore) const

   307 	{

   308 	RStoreWriteStream stream;

   309 	TStreamId id=stream.CreateLC(aStore);

   310 	ExternalizeL(stream);

   311 	stream.CommitL();

   312 	CleanupStack::PopAndDestroy();

   313 	return id;

   314 	}

   316 void CShape::RestoreL(const CStreamStore& aStore,TStreamId anId)

   317 	{

   318 	RStoreReadStream stream;

   319 	stream.OpenLC(aStore,anId);

   320 	InternalizeL(stream);

   321 	CleanupStack::PopAndDestroy();

   322 	}

   324 CShape* CSquare::New()

   325 	{

   326 	return new CSquare;

   327 	}

   329 CSquare::CSquare(const TPoint& aCentre,TInt aSide)

   330 	{

   331 	TInt offset=aSide/2;

   332 	iRect.iTl.iX=aCentre.iX-offset;

   333 	iRect.iTl.iY=aCentre.iY-offset;

   334 	iRect.iBr.iX=iRect.iTl.iX+aSide;

   335 	iRect.iBr.iY=iRect.iTl.iY+aSide;

   336 	}

   338 void CSquare::ExternalizeL(RWriteStream& aStream) const

   339 	{

   340 	aStream.WriteUint32L(iRect.iTl.iX);

   341 	aStream.WriteUint32L(iRect.iTl.iY);

   342 	aStream.WriteUint32L(iRect.iBr.iX);

   343 	aStream.WriteUint32L(iRect.iBr.iY);

   344 	}

   346 void CSquare::InternalizeL(RReadStream& aStream)

   347 	{

   348 	iRect.iTl.iX=aStream.ReadUint32L();

   349 	iRect.iTl.iY=aStream.ReadUint32L();

   350 	iRect.iBr.iX=aStream.ReadUint32L();

   351 	iRect.iBr.iY=aStream.ReadUint32L();

   352 	}

   354 TPtrC CSquare::Name() const

   355 	{

   356 	return _L("Square");

   357 	}

   359 TSize CSquare::Extent() const

   360 	{

   361 	return (iRect.iBr-iRect.iTl).AsSize();

   362 	}

   364 TPoint CSquare::Centre() const

   365 	{

   366 	return TPoint((iRect.iBr.iX-iRect.iTl.iX)/2,(iRect.iBr.iY-iRect.iTl.iY)/2);

   367 	}

   369 CShape* CCircle::New()

   370 	{

   371 	return new CCircle;

   372 	}

   374 CCircle::CCircle(const TPoint& aCentre,TInt aRadius)

   375 	: iCentre(aCentre),iRadius(aRadius)

   376 	{}

   378 void CCircle::ExternalizeL(RWriteStream& aStream) const

   379 	{

   380 	aStream.WriteUint32L(iCentre.iX);

   381 	aStream.WriteUint32L(iCentre.iY);

   382 	aStream.WriteUint32L(iRadius);

   383 	}

   385 void CCircle::InternalizeL(RReadStream& aStream)

   386 	{

   387 	iCentre.iX=aStream.ReadUint32L();

   388 	iCentre.iY=aStream.ReadUint32L();

   389 	iRadius=aStream.ReadUint32L();

   390 	}

   392 TPtrC CCircle::Name() const

   393 	{

   394 	return _L("Circle");

   395 	}

   397 TSize CCircle::Extent() const

   398 	{

   399 	TInt diameter=iRadius*2;

   400 	return TSize(diameter,diameter);

   401 	}

   403 TPoint CCircle::Centre() const

   404 	{

   405 	return iCentre;

   406 	}

   408 TShapeHolder::TShapeHolder()

   409 	: iType(ENotAShape),iShape(NULL)

   410 	{}

   412 TShapeHolder::TShapeHolder(TShape aType,CShape* aShape)

   413 	: iType(aType),iShape(aShape)

   414 	{

   415 	__ASSERT_DEBUG((iType==ENotAShape)==(aShape==NULL),User::Panic(_L("gargl"),0));

   416 	}

   418 void TShapeHolder::ExternalizeL(RWriteStream& aStream) const

   419 	{

   420 	aStream.WriteUint8L(iType);

   421 	aStream<<iShape;

   422 	}

   424 void TShapeHolder::InternalizeL(RReadStream& aStream)

   425 	{

   426 	TShape type=TShape(aStream.ReadUint8L());

   427 	if ((type==ENotAShape)!=(CShape::Ctor(type)==NULL))

   428 		User::Leave(KErrCorrupt); // representation violation!!!

   429 //

   430 	aStream>>iShape;

   431 	iType=type;

   432 	}

   434 void TShapeHolder::StoreComponentsL(CStreamStore& aStore,CStoreMap& aMap) const

   435 	{

   436 	if (iShape!=NULL)

   437 		{

   438 		TStreamId id=iShape->StoreL(aStore);

   439 		aMap.BindL(iShape,id);

   440 		}

   441 	}

   443 void TShapeHolder::RestoreComponentsL(const CStreamStore& aStore)

   444 	{

   445 	TShapeCtor ctor=CShape::Ctor(iType);

   446 	CShape* shape=NULL;

   447 	if (ctor!=NULL)

   448 		{

   449 		User::LeaveIfNull(shape=(*ctor)());

   450 		CleanupStack::PushL(shape);

   451 		shape->RestoreL(aStore,iShape.AsId());

   452 		CleanupStack::Pop();

   453 		}

   454 	iShape=shape;

   455 	}

   457 void TShapeHolder::ExternalizeSerialL(RWriteStream& aStream) const

   458 	{

   459 	aStream.WriteUint8L(iType);

   460 	if (iShape!=NULL)

   461 		aStream<<*iShape;

   462 	}

   464 void TShapeHolder::InternalizeSerialL(RReadStream& aStream)

   465 	{

   466 	TShape type=TShape(aStream.ReadUint8L());

   467 	TShapeCtor ctor=CShape::Ctor(type);

   468 	if ((type==ENotAShape)!=(ctor==NULL))

   469 		User::Leave(1832); // representation violation!!!

   470 //

   471 	CShape* shape=NULL;

   472 	if (ctor!=NULL)

   473 		{

   474 		User::LeaveIfNull(shape=(*ctor)());

   475 		CleanupStack::PushL(shape);

   476 		aStream>>*shape;

   477 		CleanupStack::Pop();

   478 		}

   479 	iType=type;

   480 	iShape=shape;

   481 	}

   483 TStreamId TShapeHolder::StoreL(CStreamStore& aStore) const

   484 	{

   485 	CStoreMap* map=CStoreMap::NewLC(aStore);

   486 	StoreComponentsL(aStore,*map);

   487 //

   488 	RStoreWriteStream stream(*map);

   489 	TStreamId id=stream.CreateLC(aStore);

   490 	ExternalizeL(stream);

   491 	stream.CommitL();

   492 //

   493 	map->Reset();

   494 	CleanupStack::PopAndDestroy(2);

   495 	return id;

   496 	}

   498 void TShapeHolder::RestoreL(const CStreamStore& aStore,TStreamId anId)

   499 	{

   500 	RStoreReadStream stream;

   501 	stream.OpenLC(aStore,anId);

   502 	InternalizeL(stream);

   503 	CleanupStack::PopAndDestroy();

   504 //

   505 	RestoreComponentsL(aStore);

   506 	}

   508 CShape* TShapeHolder::Shape() const

   509 	{

   510 	return iShape;

   511 	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--