1 // Copyright (c) 2008-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 the License "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 // f32test\cfileman\t_cfileman_aux.cpp

    15 // 

    16 //

    17 

    18 #include "t_cfileman_aux.h"

    19 

    20 CFileMan* gFileMan = NULL;

    21 RPointerArray<RFile>* gFileHandles = NULL;

    22 TBool gAsynch = EFalse;

    23 TRequestStatus gStat;

    24 TBool testingInvalidPathLengths;

    25 

    26 void InitialiseL()

    27 	{

    28 	gFileMan=CFileMan::NewL(TheFs);

    29 	}

    30 

    31 void RmDir(const TDesC& aDirName)

    32 	{

    33 	TFileName filename_dir = aDirName;

    34 	TInt r = 0;

    35 	r = TheFs.SetAtt(filename_dir, 0, KEntryAttReadOnly);

    36 	r=gFileMan->RmDir(filename_dir);

    37 	test(r==KErrNone || r==KErrNotFound || r==KErrPathNotFound);

    38 	}

    39 

    40 // Cleanup test variables

    41 void Cleanup()

    42 	{

    43 	delete gFileMan;

    44 	}

    45 

    46 //Test that the contents of two directories are identical

    47 TBool CompareL(const TDesC& aDir1,const TDesC& aDir2)

    48 	{

    49 	TBool rel = ETrue;

    50 	CDirScan* scanDir1=CDirScan::NewL(TheFs);

    51 	scanDir1->SetScanDataL(aDir1,KEntryAttMaskSupported,ESortByName);

    52 	CDirScan* scanDir2=CDirScan::NewL(TheFs);

    53 	scanDir2->SetScanDataL(aDir2,KEntryAttMaskSupported,ESortByName);

    54 

    55 	FOREVER

    56 		{

    57 		CDir* entryList1;

    58 		CDir* entryList2;

    59 

    60 		scanDir1->NextL(entryList1);

    61 		scanDir2->NextL(entryList2);

    62 

    63 		if (entryList1==NULL || entryList2==NULL)

    64 			{

    65 			if (!(entryList1==NULL && entryList2==NULL))

    66 				{

    67 				delete entryList1, 

    68 				delete entryList2, 

    69 				delete scanDir1, 

    70 				delete scanDir2;

    71 				return(EFalse);

    72 				}

    73 			break;

    74 			}

    75 

    76 		TFileName abbPath1=scanDir1->AbbreviatedPath();

    77 		TFileName abbPath2=scanDir2->AbbreviatedPath();

    78 		if (!(abbPath1==abbPath2))

    79 			{

    80 			delete entryList1, 

    81 			delete entryList2, 

    82 			delete scanDir1, 

    83 			delete scanDir2;

    84 			return(EFalse);

    85 			}

    86 

    87 		TInt count1=entryList1->Count();

    88 		TInt count2=entryList2->Count();

    89 		if (!(count1==count2))

    90 			{

    91 			delete entryList1, 

    92 			delete entryList2, 

    93 			delete scanDir1, 

    94 			delete scanDir2;

    95 			return(EFalse);

    96 			}

    97 

    98 		while(count1--)

    99 			{

   100 			TEntry entry1=(*entryList1)[count1];

   101 			TEntry entry2=(*entryList2)[count1];

   102 			if (!(entry1.iName==entry2.iName))

   103 				{

   104 				delete entryList1, 

   105 				delete entryList2, 

   106 				delete scanDir1, 

   107 				delete scanDir2;

   108 				return(EFalse);

   109 				}

   110 			if (!(entry1.iAtt==entry2.iAtt))

   111 				{

   112 				delete entryList1, 

   113 				delete entryList2, 

   114 				delete scanDir1, 

   115 				delete scanDir2;

   116 				return(EFalse);

   117 				}

   118 

   119 			}

   120 

   121 		delete entryList1;

   122 		delete entryList2;

   123 		}

   124 

   125 	delete scanDir1;

   126 	delete scanDir2;

   127 	

   128 	return rel;

   129 	}

   130 

   131 /**

   132     Parsing Dir Data Block

   133     @param  aDataBlock		data block in TInt[] for parsing	

   134     @param  aDirDataArray	returning dir data array after parsing

   135 

   136     @panic 					if data setup error

   137 

   138 */

   139 void ParsingDirDataBlock(const TInt aDataBlock[], RArray<TInt>& aDirDataArray)

   140 	{

   141 	TInt err = KErrNone;

   142 	aDirDataArray.Reset();

   143 

   144 	if (aDataBlock[0] == EOB)

   145 		{

   146 		return;

   147 		}

   148 

   149 	TInt i = 1;

   150 	FOREVER

   151 		{

   152 		TInt lastItem = aDataBlock[i-1];

   153 		TInt currentItem = aDataBlock[i];

   154 		

   155 		// check currentItem

   156 		if (currentItem == EOB)

   157 			{

   158 			if (lastItem == CON || lastItem > LAST)

   159 			//check last

   160 				{

   161 				test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);

   162 				test(EFalse);

   163 				}

   164 			else

   165 			// passed, insert last, break

   166 				{

   167 				err = aDirDataArray.InsertInOrder(lastItem);

   168 				if (err != KErrNone && err != KErrAlreadyExists)

   169 					{

   170 					test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);

   171 					test(EFalse);

   172 					}

   173 				break;

   174 				}

   175 			}

   176 		

   177 		else if (currentItem == CON)

   178 		// if current == CON

   179 			{

   180 			if (lastItem == CON || lastItem >= LAST)

   181 			// check last item

   182 				{

   183 				test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);

   184 				test(EFalse);

   185 				}

   186 			else // last < LAST, last != CON

   187 				{

   188 				// check next item

   189 				TInt nextItem = aDataBlock[i+1];

   190 				if (nextItem <= 0 || nextItem > LAST || lastItem >= nextItem)

   191 					{

   192 					test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);

   193 					test(EFalse);

   194 					}

   195 				else

   196 					{

   197 					// all valid

   198 					for (TInt j = lastItem; j < nextItem; j++)

   199 						{

   200 						err = aDirDataArray.InsertInOrder(j);

   201 						if (err != KErrNone && err != KErrAlreadyExists)

   202 							{

   203 							test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);

   204 							test(EFalse);

   205 							}

   206 						}

   207 					}

   208 				}

   209 			i++;

   210 			}

   211 

   212 		else if (0 <= currentItem && currentItem <= LAST)

   213 		// if current == normal item

   214 			{

   215 			if (lastItem == CON)

   216 				{

   217 				i++;

   218 				continue;

   219 				}

   220 			else if (lastItem >= LAST)

   221 			// check last item

   222 				{

   223 				test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);

   224 				test(EFalse);

   225 				}

   226 			else

   227 			// passed, insert last

   228 				{

   229 				err = aDirDataArray.InsertInOrder(lastItem);

   230 				if (err != KErrNone && err != KErrAlreadyExists)

   231 					{

   232 					test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);

   233 					test(EFalse);

   234 					}

   235 				}

   236 			i++;

   237 			}

   238 		

   239 		else	// invalid input

   240 			{

   241 			test.Printf(_L("ERROR<SetupDir>: wrong dir data setup! err=%d\n"), err);

   242 			test(EFalse);

   243 			}

   244 		}

   245 	}

   246 

   247 	

   248 /**

   249 	Setup attribs:

   250 	@param  filenamedir   		root path of dir data or a file data

   251 	@param  mode			    value of an mode to be set(Normal/Open/Shared..)

   252 */

   253 void OpenFile(TDesC& aFile, TFileMode aFileMode)

   254 	{

   255 	RFile* file = new (ELeave) RFile;

   256 	gFileHandles->Append(file);

   257 	TInt ret = 0;

   258 	ret = file->Open(TheFs, aFile, aFileMode);

   259 	test(ret==KErrNone);

   260 	}

   261 	

   262 

   263 /**

   264     Setup dir structure for testing and verifying functional results

   265     @param	datastr			data structure to setup directory

   266     @param  iOperation   	Operation to be performed 

   267     @param  SrcDrive		Source drive

   268     @param	Targetdrive		Target drive input

   269     @panic					if data structure definition is incorrect

   270 */

   271 void SetupDirFiles(const TDesC& aPath, const TDirSetupFiles& aDirFiles)

   272 	{

   273 	TFileName path = aPath;

   274 	if (path.Length() == 0)

   275 		{

   276 		test.Printf(_L("ERROR<SetupDirFiles()>: Zero length src path!\n"));

   277 		test(EFalse);

   278 		}

   279 	

   280 	RmDir(path);

   281 	MakeDir(path);

   282 

   283 	RArray<TInt> addBlockDataArray;

   284 	RArray<TInt> deductBlockDataArray;

   285 	

   286 	ParsingDirDataBlock(aDirFiles.iAddingBlock, addBlockDataArray);

   287 	ParsingDirDataBlock(aDirFiles.iDeductBlock, deductBlockDataArray);

   288 	

   289 	if (addBlockDataArray.Count() == 0)

   290 	// empty dir setup

   291 		{

   292 		return;

   293 		}

   294 	else

   295 		{

   296 		for (TInt i = 0; i < deductBlockDataArray.Count(); ++i)

   297 			{

   298 			TInt idxToDelete = addBlockDataArray.FindInOrder(deductBlockDataArray[i]);

   299 			if (idxToDelete >= 0)

   300 				{

   301 				addBlockDataArray.Remove(idxToDelete);

   302 				}

   303 			else if (idxToDelete == KErrNotFound)

   304 				{

   305 				continue;

   306 				}

   307 			else

   308 				{

   309 				test.Printf(_L("ERROR<<SetupDir>>: wrong dir data setup! err=%d\n"), idxToDelete);

   310 				test(EFalse);

   311 				}

   312 			}

   313 		}

   314 

   315 	if (addBlockDataArray.Count() > 0)

   316 		{

   317 		for (TInt i = 0; i < addBlockDataArray.Count(); ++i)

   318 			{

   319 			TInt idx = addBlockDataArray[i];

   320 			path = aPath;

   321 			path += gDirPatterns[idx];

   322 			if (path[path.Length() - 1] == '\\')

   323 				{

   324 				MakeDir(path);

   325 				}

   326 			else

   327 				{

   328 				MakeFile(path, _L8("blahblah"));

   329 

   330 				}

   331 			}

   332 		}

   333 

   334 	addBlockDataArray.Reset();

   335 	deductBlockDataArray.Reset();

   336 	}

   337 

   338 /**

   339     Print out all items in aPath

   340     @param  aPath 		root path for scanning

   341 

   342     @panic				SetScanData error

   343 */

   344 void PrintDir(const TDesC& aPath, const TChar& aDrv)

   345 	{

   346 	TFileName fn;

   347 	if (aPath.Length() == 0)

   348 		{

   349 		return;

   350 		}

   351 	else

   352 		{

   353 		fn = aPath;

   354 		fn[0] = (TUint16)aDrv;

   355 		test.Printf(_L("==============================\n"));

   356 		test.Printf(_L("<<PrintDir>>: root = \"%S\"\n"), &fn);

   357 		}

   358 

   359 	CDirScan* scan = CDirScan::NewL(TheFs);

   360 	TUint entryAttMask = KEntryAttMaskSupported;

   361 	TUint entrySortMask = EDirsLast|EAscending;

   362 	CDirScan::TScanDirection scanDirection = CDirScan::EScanDownTree;

   363 

   364 

   365 	TRAPD(err, scan->SetScanDataL(fn, entryAttMask, entrySortMask, scanDirection));

   366 	test(err == KErrNone);

   367 

   368 	CDir* dir = NULL;

   369 	TInt i = 0;

   370 	TBool temp_val = ETrue;

   371 	while (temp_val)

   372 		{

   373 		scan->NextL(dir);

   374 		if (dir != NULL)

   375 			{

   376 			for (TInt j = 0; j < dir->Count(); ++j)

   377 				{

   378 				TFileName item(fn.Left(aPath.Length() - 1));

   379 				item.Append(scan->AbbreviatedPath());

   380 				TEntry dummy = (*dir)[j];

   381 				item.Append(dummy.iName);

   382 				if (dummy.iAtt & KEntryAttDir)

   383 					{

   384 					item.Append('\\');

   385 					}

   386 				test.Printf(_L("<<PrintDir>>: item %d: \"%S\"\n"), i, &item);

   387 				++i;

   388 				}

   389 			delete dir;

   390 			dir = NULL;

   391 			}

   392 		else

   393 			{

   394 			break;

   395 			}

   396 		}

   397 	delete scan;

   398 	}