Symaptic: os/persistentdata/persistentstorage/store/TFILE/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 LOCAL_D RTest test(_L("t_storfserr"));

    21 #ifdef _DEBUG

    23 LOCAL_D CTrapCleanup* TheTrapCleanup = NULL;

    24 LOCAL_D RFs TheFs;

    26 const TInt KTestCleanupStack=0x20;

    27 const TPtrC KTestDir=_L("\\STOR-TST\\T_FSERR\\");

    28 const TPtrC FileNameA=_L("A.DAT");

    29 const TPtrC FileNameB=_L("B.DAT");

    31 const TPtrC des2(_S("22"),2);

    32 const TPtrC des3(_S("333"),3);

    33 const TPtrC des4(_S("4444"),4);

    34 const TPtrC des5(_S("55555"),5);

    35 LOCAL_D CFileStore* store = NULL;

    36 RStoreWriteStream out;

    37 RStoreReadStream in;

    39 LOCAL_C void setupCleanup()

    40     {// Initialise the cleanup stack

    41 	TheTrapCleanup=CTrapCleanup::New();

    42 	test(TheTrapCleanup!=NULL);

    43 	TRAPD(r,\

    44 		{\

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

    46 			CleanupStack::PushL((TAny*)0);\

    47 		CleanupStack::Pop(KTestCleanupStack);\

    48 		});

    49 	test(r==KErrNone);

    50 	}

    52 LOCAL_C void setupTestDirectory()

    53     {// Prepare the test directory.

    54 	TInt r=TheFs.MkDirAll(KTestDir);

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

    56 	r=TheFs.SetSessionPath(KTestDir);

    57 	test(r==KErrNone);

    58 	}

    60 LOCAL_D void AlterStoreL(TInt aFail)

    61 	{

    62 	RStoreWriteStream out2;

    63 	RStoreWriteStream out3;

    64 	RStoreWriteStream out4;

    65 	RStoreReadStream in;

    66 	TheFs.SetErrorCondition(KErrNotReady,aFail);

    67 	TStreamId id0 = out.CreateLC(*store);

    68 	out << _L("012345678901234567890123456789012345678901234567890123456789");

    69 	out.CommitL();

    70 	CleanupStack::PopAndDestroy();

    72 	TStreamId id2 = out.CreateLC(*store);

    73 	out.CommitL();

    74 	CleanupStack::PopAndDestroy();

    76 	TStreamId id3 = out.CreateLC(*store);

    77 	out.CommitL();

    78 	CleanupStack::PopAndDestroy();

    80 	TStreamId id4 = out.CreateLC(*store);

    81 	out << _L("mum");

    82 	out.CommitL();

    83 	CleanupStack::PopAndDestroy();

    85 	out.ReplaceLC(*store,store->Root());

    86 	out << id2;

    87 	out << id3;

    88 	out << id4;

    89 	out << KNullStreamId;

    90 	out << KNullStreamId;

    91 	out.CommitL();

    92 	CleanupStack::PopAndDestroy();

    94 	in.OpenLC(*store,store->Root());// use the root for in and out streams

    95 	out.ReplaceLC(*store,store->Root());

    96 	out.WriteL(in);

    97 	out.CommitL();

    98 	CleanupStack::PopAndDestroy(2);

   100 	out.ReplaceLC(*store,store->Root());// swap the order

   101 	in.OpenLC(*store,store->Root());

   102 	out.WriteL(in);

   103 	out << KNullStreamId;

   104 	out.CommitL();

   105 	CleanupStack::PopAndDestroy(2);

   107 	store->CommitL();

   109 	in.OpenLC(*store,store->Root());

   110 	TStreamId idX,idZ;

   111 	in >> idX;

   112 	in >> idX;

   113 	in >> idZ;// id4 "mum"

   114 	CleanupStack::PopAndDestroy();

   115 	out.OpenLC(*store,idZ);

   116 	in.OpenLC(*store,idZ);

   117 	out2.OpenLC(*store,idZ);

   118 	out3.OpenLC(*store,idZ);

   119 	out4.OpenLC(*store,idZ);

   120 	out4.WriteL(in);

   121 	out.CommitL();

   122 	CleanupStack::PopAndDestroy(5);

   124 	store->CompactL();

   125 	store->CommitL();

   127 	store->DeleteL(id0);

   128 	store->CommitL();

   130 	store->CompactL();

   131 	store->CommitL();

   132 	}

   134 enum TFileQoS

   135 	{

   136 	ESimple			= 0,//File, "write byte" is an atomic operation

   137 	EBlockAtomic	= 1,//File, "block write" is an atomic operation

   138 	ETransactional	= 2,//Transactional file system.

   139 	ELastQoSType

   140 	};

   142 const TInt KFailPoints[ELastQoSType][2] =

   143 	{

   144 	// non-transactional file system

   145 		{

   146 		5, 54

   147 		},

   148 	// atomic "block write"

   149 		{

   150 		3, 38

   151 		},

   152 	// transactional file system

   153 		{

   154 		3, 38

   155 		}

   156 	};

   158 //The function returns true, if the file system guarantees atomic "block write" operations on aDriveNo.

   159 TBool IsBlockAtomic(TInt aDriveNo)

   160 	{

   161 	__ASSERT_DEBUG(aDriveNo >= EDriveA && aDriveNo <= EDriveZ, User::Invariant());

   163 	TVolumeIOParamInfo volInfo;

   164 	TInt err = TheFs.VolumeIOParam(aDriveNo, volInfo);

   165 	//If VolumeIOParam() succeeds, the media block size is >= 512 bytes and the media block size is power of two - report

   166 	//that the media supports atomic "block write" operations.

   167 	const TInt KDefaultMediaBlockSize = 512;

   168 	return err == KErrNone && volInfo.iBlockSize >= KDefaultMediaBlockSize && (volInfo.iBlockSize & (volInfo.iBlockSize - 1)) == 0;

   169 	}

   171 TFileQoS MediaType(const TDesC& aFilename)

   172 	{

   173 	TParse p;

   174 	TheFs.Parse(aFilename, p);

   175 	TDriveInfo dinfo;

   176 	TheFs.Drive(dinfo, TDriveUnit(p.Drive()));

   177 	TBool transactional = dinfo.iDriveAtt & KDriveAttTransaction;

   178 	if(transactional)

   179 		{

   180 		return ETransactional;

   181 		}

   182 	if(IsBlockAtomic(TDriveUnit(p.Drive())))

   183 		{

   184 		return EBlockAtomic;

   185 		}

   186 	return ESimple;

   187 	}

   188 /**

   189 @SYMTestCaseID          SYSLIB-STORE-CT-1160

   190 @SYMTestCaseDesc	    File server test

   191 @SYMTestPriority 	    High

   192 @SYMTestActions  	    Tests for failure on call to file server

   193 @SYMTestExpectedResults Test must not fail

   194 @SYMREQ                 REQ0000

   195 */

   196 LOCAL_D void FailOnEveryFileServerCallL()

   197 	{

   198 	TheFs.Delete(FileNameA);

   200 	const TFileQoS KMediaType = MediaType(FileNameA);

   201 	_LIT(KSimpleText, "Simple");

   202 	_LIT(KAtomicText, "Atomic block \"write\"");

   203 	_LIT(KTransactionalText, "Transactional");

   204 	const TPtrC mediaType[ELastQoSType] = {KSimpleText(), KAtomicText(), KTransactionalText()};

   205 	test.Printf(_L("Media type: %S\r\n"), &mediaType[KMediaType]);

   207 	const TInt KStoreCommitted = KFailPoints[KMediaType][0];

   208 	const TInt KLastFail = KFailPoints[KMediaType][1];

   210 	const TInt KError = KErrNotReady;

   211 	const TInt KRootIdSizeBeforeStoreCommit = 0;

   212 	const TInt KRootIdSizeAfterStoreCommit = 6*sizeof(TStreamId);

   214 	for (TInt fail=1;fail<=KLastFail+5;++fail)

   215 		{

   216 		store=CPermanentFileStore::ReplaceLC(TheFs,FileNameA,EFileWrite|EFileRead);

   217 		store->SetTypeL(KPermanentFileStoreLayoutUid);

   218 		TStreamId rootId = store->ExtendL();

   219 		store->SetRootL(rootId);

   220 		store->CommitL();

   221 		TRAPD(r,AlterStoreL(fail));

   222 		TheFs.SetErrorCondition(KErrNone);

   223 		if (fail<KLastFail)

   224 			test(r==KError);

   225 		else

   226 			test(r==KErrNone);

   227 		TRAP(r,store->RevertL());

   228 		if (r==KErrNotReady)

   229 			{

   230 			CleanupStack::PopAndDestroy();

   231 			store=CPermanentFileStore::OpenLC(TheFs,FileNameA,EFileWrite|EFileRead);

   232 			}

   233 		else

   234 			test(r==KErrNone);

   235 		CleanupStack::PopAndDestroy();

   236 //

   237 		// open read only

   238 		store=CPermanentFileStore::OpenLC(TheFs,FileNameA,EFileRead);

   239 		RStoreReadStream in;

   240 		in.OpenLC(*store,store->Root());

   241 		TInt size=in.Source()->SizeL();

   242 		if (fail<KStoreCommitted)

   243 			test(size==KRootIdSizeBeforeStoreCommit);

   244 		else //fail>=KStoreCommitted

   245 			test(size==KRootIdSizeAfterStoreCommit);

   246 		CleanupStack::PopAndDestroy(2);

   247 //

   248 		store=CPermanentFileStore::OpenLC(TheFs,FileNameA,EFileRead|EFileWrite);

   249 		store->ExtendL();

   250 		store->RevertL();

   251 		in.OpenLC(*store,store->Root());

   252 		size=in.Source()->SizeL();

   253 		if (fail<KStoreCommitted)

   254 			test(size==KRootIdSizeBeforeStoreCommit);

   255 		else //fail>=KStoreCommitted

   256 			test(size==KRootIdSizeAfterStoreCommit);

   257 		CleanupStack::PopAndDestroy(2);

   258 		}

   259 	}

   261 LOCAL_D void InitialseStoreWithDataL()

   262 	{

   263 	TheFs.Delete(FileNameB);

   264 	store=CPermanentFileStore::CreateLC(TheFs,FileNameB,EFileWrite|EFileRead);

   265 	store->SetTypeL(KPermanentFileStoreLayoutUid);

   266 	TStreamId rootId = store->ExtendL();

   267 	store->SetRootL(rootId);

   268 	store->CommitL();

   269 	CleanupStack::PopAndDestroy();

   271 	store=CPermanentFileStore::OpenLC(TheFs,FileNameB,EFileWrite|EFileRead);

   272 	TStreamId id2 = out.CreateLC(*store);

   273 	out << des2;

   274 	out.CommitL();

   275 	CleanupStack::PopAndDestroy();

   277 	TStreamId id3 = out.CreateLC(*store);

   278 	out << des3;

   279 	out.CommitL();

   280 	CleanupStack::PopAndDestroy();

   282 	out.ReplaceLC(*store,store->Root());

   283 	out << id2;

   284 	out << id3;

   285 	out.CommitL();

   286 	CleanupStack::PopAndDestroy();// out

   288 	store->CommitL();

   289 	CleanupStack::PopAndDestroy();// store

   290 	}

   292 LOCAL_D void AlterStoreDuringFileServerErrorL(TInt aError)

   293 	{

   294 	store=CPermanentFileStore::OpenLC(TheFs,FileNameB,EFileWrite|EFileRead);

   295 	in.OpenLC(*store,store->Root());

   296 	TStreamId id2;

   297 	TStreamId id3;

   298 	in >> id2;

   299 	in >> id3;

   300 	CleanupStack::PopAndDestroy();// in

   302 	out.ReplaceLC(*store,id2);

   303 	out << des4;

   304 	out.CommitL();

   305 	CleanupStack::PopAndDestroy();// out

   306 	TheFs.SetErrorCondition(aError);

   307 	out.ReplaceLC(*store,id3);

   308 	out << des5;

   309 	out.CommitL();

   310 	CleanupStack::PopAndDestroy();// out

   312 	store->CommitL();

   313 	CleanupStack::PopAndDestroy();// store

   314 	}

   316 LOCAL_D void TestStreamDataL(TInt aError)

   317 	{

   318 	store=CPermanentFileStore::OpenLC(TheFs,FileNameB,EFileWrite|EFileRead);

   319 	in.OpenLC(*store,store->Root());

   320 	TStreamId id2;

   321 	TStreamId id3;

   322 	in >> id2;

   323 	in >> id3;

   324 	CleanupStack::PopAndDestroy();// in

   326 	TBuf<16> buf;

   328 	in.OpenLC(*store,id2);

   329 	in >> buf;

   330 	if (aError==KErrNone)

   331 		test(buf==_L("4444"));// store committed

   332 	else

   333 		test(buf==_L("22"));// store reverted

   335 	CleanupStack::PopAndDestroy();// in

   337 	in.OpenLC(*store,id3);

   338 	in >> buf;

   339 	if (aError==KErrNone)

   340 		test(buf==_L("55555"));// store committed

   341 	else

   342 		test(buf==_L("333"));// store reverted

   344 	CleanupStack::PopAndDestroy();// in

   346 	CleanupStack::PopAndDestroy();// store

   347 	}

   349 LOCAL_D void ResetStreamDataL()

   350 	{

   351 	store=CPermanentFileStore::OpenLC(TheFs,FileNameB,EFileWrite|EFileRead);

   352 	in.OpenLC(*store,store->Root());

   353 	TStreamId id2;

   354 	TStreamId id3;

   355 	in >> id2;

   356 	in >> id3;

   357 	CleanupStack::PopAndDestroy();// in

   359 	out.ReplaceLC(*store,id2);

   360 	out << des2;

   361 	out.CommitL();

   362 	CleanupStack::PopAndDestroy();// out

   364 	out.ReplaceLC(*store,id3);

   365 	out << des3;

   366 	out.CommitL();

   367 	CleanupStack::PopAndDestroy();// out

   369 	store->CommitL();

   370 	CleanupStack::PopAndDestroy();// store

   371 	}

   372 /**

   373 @SYMTestCaseID          SYSLIB-STORE-CT-1161

   374 @SYMTestCaseDesc	    Tests for all errors on file server

   375 @SYMTestPriority 	    High

   376 @SYMTestActions  	    Tests for stream data to a store

   377 @SYMTestExpectedResults Test must not fail

   378 @SYMREQ                 REQ0000

   379 */

   380 LOCAL_D void TestAllFsErrorL()

   381 	{

   382 	InitialseStoreWithDataL();

   383 	for (TInt error=0; error >= KErrDied; --error)

   384 		{

   385 		TRAPD(r,AlterStoreDuringFileServerErrorL(error));

   386 		TheFs.SetErrorCondition(KErrNone);

   387 		if (r!=KErrNone)

   388 			{

   389 			store = CPermanentFileStore::OpenLC(TheFs,FileNameB,EFileWrite|EFileRead);

   390 			store->RevertL();

   391 			CleanupStack::PopAndDestroy();// store

   392 			}

   393 		TestStreamDataL(error);

   394 		ResetStreamDataL();

   395 		}

   396 	}

   398 void RunTests()

   399 	{

   400 	setupTestDirectory();

   401 	__UHEAP_MARK;

   402 //

   403 	test.Start(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1160 Random failure on every file server call "));

   404 	TRAPD(r,FailOnEveryFileServerCallL());

   405 	test(r==KErrNone);

   406 	test.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1161 Alter STORE during file server error "));

   407 	TRAP(r,TestAllFsErrorL());

   408 	test(r==KErrNone);

   409 	test.End();

   411 	TheFs.Delete(FileNameA);

   412 	TheFs.Delete(FileNameB);

   413 //

   414 	__UHEAP_MARKEND;

   415 	}

   417 #endif	// _DEBUG

   419 GLDEF_C TInt E32Main()

   420     {// Test permanent file store.

   421 	test.Title();

   422 #ifdef _DEBUG

   423 	TInt r=TheFs.Connect();

   424 	test(r==KErrNone);

   425 	setupCleanup();

   426 	RunTests();

   427 	delete TheTrapCleanup;

   428 	TheFs.Close();

   429 #else

   430 	test.Start(_L("The tests are not valid in release mode"));

   431 	test.End();

   432 #endif

   433 	test.Close();

   434 	return 0;

   435     }

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