Symaptic: os/ossrv/genericservices/httputils/Test/t_fileuri/CFileUriTest.cpp@260cb5ec6c19

     1 // Copyright (c) 2004-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 // Note : Testing for file uri component extraction for external media drive will be done only

    15 // if an external media drive does exist

    16 //

    17 //

    19 #include "CFileUriTest.h"

    21 #include <e32base.h>

    22 #include <escapeutils.h>

    23 #include "FileUriTestCommon.h"

    25 //File URI Constents

    26 _LIT8(KFileUriScheme8, "file");

    27 _LIT16(KFileUriScheme16, "file");

    29 //

    30 //

    31 //	File Uri Tests

    32 //

    33 //

    35 CFileUriTest* CFileUriTest::NewLC(CIpuTestHarness* aTestHarness)

    36 	{

    37 	CFileUriTest* self = new (ELeave) CFileUriTest(aTestHarness);

    38 	CleanupStack::PushL(self);

    39 	self->ConstructL();

    40 	return self;

    41 	}

    43 CFileUriTest* CFileUriTest::NewL(CIpuTestHarness* aTestHarness)

    44 	{

    45 	CFileUriTest* self = CFileUriTest::NewLC(aTestHarness);

    46 	CleanupStack::Pop(self);

    47 	return self;

    48 	}

    50 CFileUriTest::CFileUriTest(CIpuTestHarness* aTestHarness)

    51 : iTestHarness(aTestHarness)

    52 	{

    53 	}

    55 void CFileUriTest::ConstructL()

    56 	{

    57 	}

    59 CFileUriTest::~CFileUriTest()

    60 	{

    61 	}

    63 void CFileUriTest::DoTestsL()

    64 	{

    65 	TBuf<3> drive(_L("$:\\"));

    66 	//File URI Creation Test - for public files on fixed and removable media

    67 	//----------------------------------------------------------------------------------

    68 	_LIT(KFullFileName, "c:\\public\\bar\\foo\\some\\randomness.txt");

    70 	//Testing 8-bit & 16-bit File URI creation for public file on a fixed drive

    71 	_LIT(KExpectedUri, "file://c/public/bar/foo/some/randomness.txt");

    72 	TestFileUriCreationL(KFullFileName, KExpectedUri, 0);

    74 	_LIT(KFullFileName2, "c:\\dummy\\file.txt");

    75  	_LIT(KExpectedUri3, "file://c/dummy/file.txt");

    76 	TestFileUriCreationL(KFullFileName2, KExpectedUri3, 0);

    78 	_LIT(KFullFileName1, "c:\\randomness.txt");

    80 	//Testing 8-bit & 16-bit File URI creation for public file on a fixed drive

    81 	_LIT(KExpectedUri2, "file://c/randomness.txt");

    82 	TestFileUriCreationL(KFullFileName1, KExpectedUri2, 0);

    84 	//Testing 8-bit & 16-bit File URI creation for public file on a removable media drive

    85 	_LIT(KExpectedUri1, "file://ext-media/public/bar/foo/some/randomness.txt");

    86 	TestFileUriCreationL(KFullFileName, KExpectedUri1, EExtMedia);

    88 	_LIT(KExtMediaFullFileName, "X:\\mydir\\myfile.ext");

    89 	_LIT(KExtMediaExpectedUri1, "file://ext-media/mydir/myfile.ext");

    90 	TestFileUriCreationL(KExtMediaFullFileName, KExtMediaExpectedUri1, EExtMedia);

    91 	//----------------------------------------------------------------------------------

    93 	//File URI component extraction Test - Schema, Path and Filename -

    94 	// - for public files on fixed and removable media

    95 	//----------------------------------------------------------------------------------

    96 	_LIT(KFileName, "c:\\public\\bar\\foo\\some\\randomness.txt");

    98 	//Testing 8-bit & 16-bit File URI creation for public file on a fixed drive

    99 	_LIT(KExpectedPath, "/c/public/bar/foo/some/randomness.txt");

   100 	TestFileUriComponentExtractionL(KFileName, KExpectedPath, KFileName, drive, 0);

   102 	//Testing 8-bit & 16-bit File URI creation for public file on a fixed drive

   103 	_LIT(KFileName1, "c:\\system\\·····.ini");

   104 	_LIT(KExpectedPath1, "/c/system/·····.ini");

   105 	TestFileUriComponentExtractionL(KFileName1, KExpectedPath1, KFileName1, drive, 0);

   107 	//Creating files on removable media drive (X:)

   108 	// Need to change the removable Drive letter if X doesn't exist or its not removable media drive

   109 	RFs fs;

   110 	User::LeaveIfError(fs.Connect());

   111 	CleanupClosePushL(fs);

   112 	TDriveInfo driveInfo;

   113 	TInt err = KErrNotFound;

   114 	TInt driveNum = EDriveA;

   116 	//Checking for extenal media drive does exist

   117 	for (; driveNum <= EDriveZ && err!=KErrNone; driveNum++)

   118 		{

   119 		if (fs.Drive(driveInfo, driveNum ) == KErrNone

   120 			&& (driveInfo.iDriveAtt & KDriveAttRemovable))

   121 			{

   122 			drive[0]= TInt16('A' + driveNum);

   123 			err = KErrNone;

   124 			}

   125 		}

   127 	// Test only if external media drive exist

   128   	if (err == KErrNone)

   129   		{

   130   	 	driveNum--;

   132 		User::LeaveIfError(fs.SetSessionPath(drive));

   133 		TInt ret = fs.MkDir(_L("\\mydir\\"));

   134 		if (ret == KErrNone || ret == KErrAlreadyExists)

   135 			{

   136 			RFile file;

   137 			ret = file.Create(fs,_L("\\mydir\\myfile.ext"),EFileWrite|EFileShareAny);

   138 			file.Close();

   139 			if (ret == KErrNone || ret == KErrAlreadyExists)

   140 				{

   141 				//Testing 8-bit & 16-bit File URI creation for public file on a removable media drive

   142 				_LIT(KExpectedExtMediaPath1, "/ext-media/mydir/myfile.ext");

   143 				TFileName extMediaFileName(KExtMediaFullFileName);

   144 				extMediaFileName[0] = drive[0];

   145 				TestFileUriComponentExtractionL(extMediaFileName, KExpectedExtMediaPath1, extMediaFileName, drive, EExtMedia);

   146 				CFileMan* fm = CFileMan::NewL(fs);

   147 				ret = fm->RmDir(_L("\\mydir\\"));

   148 				delete fm;

   149 				}

   150 			}

   151 		}

   153 	CleanupStack::PopAndDestroy(&fs);

   154 	//----------------------------------------------------------------------------------

   156 	//File URI component extraction, obj created using CUri::NewLC Test

   157 	// - Schema, Path and Filename

   158 	//----------------------------------------------------------------------------------

   160 	TestFileUriCreationWithOldAPIAndComponentExtractionL(KFileName, KExpectedPath, KFileName );

   162 	//----------------------------------------------------------------------------------

   164 	// resolve %-codes

   165 	TestFileUriNameExtractionL(_L("file://c/dir/test/file%20name.html"), _L("file name.html"), _L("\\dir\\test\\file name.html") );

   166 	// params in path

   167 	TestFileUriNameExtractionL(_L("http://www.text.org/cgi-bin/apps/index.html;one;two;three"), _L("index.html"), _L("\\cgi-bin\\apps\\index.html") );

   169 	// resolve %-codes

   170 	TestFileUriNameExtractionL(_L8("file://c/dir/test/file%20name.html"), _L("file name.html"), _L("\\dir\\test\\file name.html") );

   172 	// params in path

   173 	TestFileUriNameExtractionL(_L8("http://www.text.org/cgi-bin/apps/index.html;one;two;three"), _L("index.html"), _L("\\cgi-bin\\apps\\index.html") );

   175 	//----------------------------------------------------------------------------------

   179 	//File URI Creation Test - for private files on fixed and removable media

   180 	//----------------------------------------------------------------------------------

   182 	//Testing 8-bit & 16-bit File URI creation for private file on a fixed drive

   183 	_LIT(KExpectedprivateUri, "file://private/Z/bar/foo/some/randomness.txt");

   185 	_LIT(KRelativeFileName, "c:\\bar\\foo\\some\\randomness.txt");

   186 	TestPrivateFileUriCreationL(KRelativeFileName, EDriveZ, KExpectedprivateUri, 0);

   188 	_LIT(KRelativeFileName1, "\\bar\\foo\\some\\randomness.txt");

   189 	TestPrivateFileUriCreationL(KRelativeFileName1, EDriveZ, KExpectedprivateUri, 0);

   191 	_LIT(KRelativeFileName2, "bar\\foo\\some\\randomness.txt");

   192 	TestPrivateFileUriCreationL(KRelativeFileName2, EDriveZ, KExpectedprivateUri, 0);

   194 	//Testing 8-bit & 16-bit File URI creation for private file on a removable media drive

   195 	_LIT(KExtMediaRelativeFileName, "\\mydir\\myfile.ext");

   196 	_LIT(KExpectedPrivateExtMediaUri, "file://private/ext-media/mydir/myfile.ext");

   197 	TestPrivateFileUriCreationL(KExtMediaRelativeFileName, EDriveZ, KExpectedPrivateExtMediaUri, EExtMedia);

   198 	//----------------------------------------------------------------------------------

   200 	//File URI component extraction Test - Schema, Path and Filename -

   201 	// - for private files on fixed and removable media

   202 	//----------------------------------------------------------------------------------

   204 	//Retrieveing application private path

   206 	User::LeaveIfError(fs.Connect());

   207 	CleanupClosePushL(fs);

   208 	TPath applPrivatePath;

   209 	User::LeaveIfError(fs.PrivatePath(applPrivatePath));

   210 	CleanupStack::PopAndDestroy(&fs);

   212 	//Testing 8-bit & 16-bit File URI creation for private file on a fixed drive

   213 	_LIT(KExpectedPrivateFilePath, "/private/Z/bar/foo/some/randomness.txt");

   214 	_LIT(KExpectedPrivateFileName, "bar\\foo\\some\\randomness.txt");

   215 	TFileName expectedPrivateFileName(_L("Z:"));

   216 	expectedPrivateFileName.Append(applPrivatePath);

   217 	expectedPrivateFileName.Append(KExpectedPrivateFileName);

   219 	TestPrivateFileUriComponentExtractionL(KRelativeFileName1, EDriveZ, KExpectedPrivateFilePath, expectedPrivateFileName, 0);

   221 	//Testing 8-bit & 16-bit File URI creation for private file on a removable media drive

   222 	_LIT(KExpectedPrivateExtMediaFilePath, "/private/ext-media/mydir/myfile.ext");

   223 	expectedPrivateFileName[0] = drive[0];

   225 	//Since we can't create folder "private" on removable media drive for testing purpose, the file extraction testing is not possible.

   226 	// So need to pass KNullDesC to avoid file extraction

   227 	TestPrivateFileUriComponentExtractionL(KExtMediaRelativeFileName, EDriveZ, KExpectedPrivateExtMediaFilePath, KNullDesC, EExtMedia);

   228 	//----------------------------------------------------------------------------------

   229 	}

   231 void CFileUriTest::TestFileUriCreationL(const TDesC16& aFullFileName, const TDesC16& aExpectedUri, TUint aFlags) const

   232 	{

   233 	//Testing 8-bit File URI creation for public file on a fixed drive

   234 	iTestHarness->StartTestL(_L("Test CUri - Public File URI creation (8bit)"));

   235 	iTestHarness->LogIt(_L("FileName: %S; \n\t\tFileStorageType:%D; \n\t\tExpected URI:%S"), &aFullFileName, aFlags, &aExpectedUri);

   236 	TInt error = KErrNone;

   237 	CUri8* uri8 = CUri8::CreateFileUriL(aFullFileName,aFlags);

   238 	CleanupStack::PushL(uri8);

   239 	HBufC8* expectedUri8 = EscapeUtils::ConvertFromUnicodeToUtf8L(aExpectedUri);

   240 	CleanupStack::PushL(expectedUri8);

   241 	error = DoFileUriExtraction<CUri8>(*uri8, *expectedUri8);

   242 	CleanupStack::PopAndDestroy(expectedUri8);

   243 	CleanupStack::PopAndDestroy(uri8);

   244 	iTestHarness->EndTest(error);

   246 	//Testing 16-bit File URI creation for public file on a fixed drive

   247 	error = KErrNone;

   248 	iTestHarness->StartTestL(_L("Test CUri - File URI creation (16bit)"));

   249 	iTestHarness->LogIt(_L("FileName: %S; \n\t\tFileType:%D; \n\t\tExpected URI:%S"), &aFullFileName, aFlags, &aExpectedUri);

   250 	CUri16* uri16 = CUri16::CreateFileUriL(aFullFileName,aFlags);

   251 	CleanupStack::PushL(uri16);

   252 	error = DoFileUriExtraction<CUri16>(*uri16, aExpectedUri);

   253 	CleanupStack::PopAndDestroy(uri16);

   254 	iTestHarness->EndTest(error);

   255 	}

   257 void CFileUriTest::TestPrivateFileUriCreationL(const TDesC16& aRelativeFileName, const TDriveNumber aDrive, const TDesC16& aExpectedUri, TUint aFlags) const

   258 	{

   259 	//Testing 8-bit File URI creation for public file on a fixed drive

   260 	iTestHarness->StartTestL(_L("Test CUri - Private File URI creation (8bit)"));

   261 	iTestHarness->LogIt(_L("FileName: %S; \n\t\tFileStorageType:%D; \n\t\tDrive:%c; \n\t\tExpectedURI:%S"), &aRelativeFileName, aFlags, ('A' + aDrive), &aExpectedUri);

   262 	TInt error = KErrNone;

   263 	CUri8* uri8 = CUri8::CreatePrivateFileUriL(aRelativeFileName,aDrive,aFlags);

   264 	CleanupStack::PushL(uri8);

   265 	HBufC8* expectedUri8 = EscapeUtils::ConvertFromUnicodeToUtf8L(aExpectedUri);

   266 	error = DoFileUriExtraction<CUri8>(*uri8, *expectedUri8);

   267 	delete expectedUri8;

   268 	CleanupStack::PopAndDestroy(uri8);

   269 	iTestHarness->EndTest(error);

   271 	//Testing 16-bit File URI creation for public file on a fixed drive

   272 	error = KErrNone;

   273 	iTestHarness->StartTestL(_L("Test CUri - Private File URI creation (16bit)"));

   274 	iTestHarness->LogIt(_L("FileName: %S; \n\t\tFileStorageType:%D; \n\t\tDrive:%c; \n\t\tExpectedURI:%S"), &aRelativeFileName, aFlags, ('A' + aDrive), &aExpectedUri);

   275 	CUri16* uri16 = CUri16::CreatePrivateFileUriL(aRelativeFileName,aDrive,aFlags);

   276 	CleanupStack::PushL(uri16);

   277 	error = DoFileUriExtraction<CUri16>(*uri16, aExpectedUri);

   278 	CleanupStack::PopAndDestroy(uri16);

   279 	iTestHarness->EndTest(error);

   280 	}

   282 void CFileUriTest::TestFileUriComponentExtractionL(const TDesC16& aFileName, const TDesC16& aPath, const TDesC16& aExpectedFileName, const TDesC16& aExpectedDrive, TUint aFlags) const

   283 	{

   284 	iTestHarness->StartTestL(_L("Test File Uri Component Extraction (8-bit)"));

   285 	iTestHarness->LogIt(_L("FileName: %S; \n\t\tFileStorageType:%D; \n\t\tPath:%S"), &aFileName,aFlags, &aPath);

   286 	HBufC8* fileUriScheme8 = HBufC8::NewLC(4);

   287 	fileUriScheme8->Des().Copy(KFileUriScheme8);

   289 	HBufC* fileUriScheme16 = HBufC::NewLC(4);

   290 	fileUriScheme16->Des().Copy(KFileUriScheme16);

   292 	RFs fs;

   293 	User::LeaveIfError(fs.Connect());

   294 	CleanupClosePushL(fs);

   295 	CFileMan *fm = CFileMan::NewL(fs);

   296 	CleanupStack::PushL(fm);

   298 	TInt len = aFileName.Length();

   299 	TInt ret = 0;

   301 	//Testing 8-bit File URI componet extraction for public file on a fixed drive

   302 	TInt error = KErrNone;

   304 	CUri8* uri8 = CUri8::CreateFileUriL(aFileName,aFlags);

   305 	CleanupStack::PushL(uri8);

   307 	HBufC8* path8 = EscapeUtils::ConvertFromUnicodeToUtf8L(aPath);

   308 	CleanupStack::PushL(path8);

   310 	HBufC8* escapedUriPath8 = EscapeUtils::EscapeEncodeL(*path8, EscapeUtils::EEscapeNormal);

   311 	CleanupStack::PushL(escapedUriPath8);

   313 	error = DoFileUriComponentExtraction<TUriParser8, CUri8>(*uri8, *fileUriScheme8, *escapedUriPath8, aExpectedFileName);

   315 	iTestHarness->EndTest(error);

   317 	//-ve testing : After renaming file it should return error

   318 	if (aFlags == EExtMedia && error == KErrNone)

   319 		{

   320 		iTestHarness->StartTestL(_L("EXT-MEDIA::Test File Uri Component Extraction(8-bit)"));

   321 		iTestHarness->LogIt(_L("FileName: %S; \n\t\tFileStorageType:%D; \n\t\tPath:%S; \n\t\tExpectedDrive:%S"), &aFileName,aFlags, &aPath, &aExpectedDrive);

   323 		error = KErrNotFound;

   324 		User::LeaveIfError(fs.SetSessionPath(aExpectedDrive));

   325 		ret = fm->Rename(aFileName,(aFileName.Left(len-4)));

   327 		if (ret == KErrNone || ret == KErrAlreadyExists)

   328 			{

   329 			TRAP(error, (DoFileUriComponentExtraction<TUriParser8, CUri8>(*uri8, *fileUriScheme8, *path8, aExpectedFileName)));

   330 			error = ((error != KErrNone) ? 0 : -1);

   331 			ret = fm->Rename(aFileName.Left(aFileName.Length()-4),aFileName,CFileMan::EOverWrite);

   332 			}

   334 		iTestHarness->EndTest(error);

   335 		}

   337 	//Testing 16-bit File URI componet extraction for public file on a removable media drive

   338 	iTestHarness->StartTestL(_L("Test File Uri Component Extraction (16-bit)"));

   339 	iTestHarness->LogIt(_L("FileName: \n\t\t%S; \n\t\tFileStorageType:%D; \n\t\tPath:%S"), &aFileName, aFlags, &aPath);

   341 	CUri16* uri16 = CUri16::CreateFileUriL(aFileName,aFlags);

   342 	CleanupStack::PushL(uri16);

   344 	HBufC* escapedUriPath = HBufC::NewLC(escapedUriPath8->Length());

   345 	escapedUriPath->Des().Copy(*escapedUriPath8);

   347 	error = DoFileUriComponentExtraction<TUriParser16, CUri16, TDesC16>(*uri16, *fileUriScheme16, *escapedUriPath, aExpectedFileName);

   349 	iTestHarness->EndTest(error);

   351 	//-ve testing : After renaming file it should return error

   352 	if (aFlags == EExtMedia && error == KErrNone)

   353 		{

   354 		iTestHarness->StartTestL(_L(" EXT-MEDIA::Test File Uri Component Extraction(16-bit)"));

   355 		iTestHarness->LogIt(_L("FileName: %S; \n\t\tFileStorageType:%D; \n\t\tPath:%S; \n\t\tExpectedDrive:%S"), &aFileName,aFlags, &aPath, &aExpectedDrive);

   357 		error = KErrNotFound;

   358 		User::LeaveIfError(fs.SetSessionPath(aExpectedDrive));

   359 		ret = fm->Rename(aFileName,(aFileName.Left(len-4)));

   361 		if (ret == KErrNone || ret == KErrAlreadyExists)

   362 			{

   363 			TRAP(error, (DoFileUriComponentExtraction<TUriParser16, CUri16, TDesC16>(*uri16, *fileUriScheme16, aPath, aExpectedFileName)));

   364 			error = ((error != KErrNone) ? 0 : -1);

   365 			ret = fm->Rename(aFileName.Left(aFileName.Length()-4),aFileName,CFileMan::EOverWrite);

   366 			}

   368 		iTestHarness->EndTest(error);

   369 		}

   371 	CleanupStack::PopAndDestroy(escapedUriPath);

   372 	CleanupStack::PopAndDestroy(uri16);

   373 	CleanupStack::PopAndDestroy(escapedUriPath8);

   374 	CleanupStack::PopAndDestroy(path8);

   375 	CleanupStack::PopAndDestroy(uri8);

   376 	CleanupStack::PopAndDestroy(4, fileUriScheme8); //fileUriScheme8, fileUriScheme16,fs,fm

   377 	}

   379 void CFileUriTest::TestPrivateFileUriComponentExtractionL(const TDesC16& aFileName, const TDriveNumber aDrive, const TDesC16& aPath, const TDesC16& aExpectedFileName, TUint aFlags) const

   380 	{

   381 	iTestHarness->StartTestL(_L("Test Private File Uri Component Extraction (8-bit)"));

   382 	iTestHarness->LogIt(_L("FileName: %S; \n\t\tDrive:%c, \n\t\tFileStorageType:%D; \n\t\tPath:%S"), &aFileName, ('A' + aDrive), aFlags, &aPath);

   383 	TInt error = KErrNone;

   384 	HBufC8* fileUriScheme8 = HBufC8::NewLC(4);

   385 	TPtr8 fileUriScheme8Ptr = fileUriScheme8->Des();

   386 	fileUriScheme8Ptr.Copy(KFileUriScheme8);

   387 	HBufC* fileUriScheme16 = HBufC::NewLC(4);

   388 	TPtr16 fileUriScheme16Ptr = fileUriScheme16->Des();

   389 	fileUriScheme16Ptr.Copy(KFileUriScheme16);

   391 	//Testing 8-bit File URI componet extraction for private file on a fixed drive

   392 	CUri8* prv_uri8 = CUri8::CreatePrivateFileUriL(aFileName,aDrive,aFlags);

   393 	CleanupStack::PushL(prv_uri8);

   394 	HBufC8* path8 = EscapeUtils::ConvertFromUnicodeToUtf8L(aPath);

   395 	error = DoFileUriComponentExtraction<TUriParser8>(*prv_uri8, *fileUriScheme8, *path8, aExpectedFileName);

   396 	delete path8;

   397 	CleanupStack::PopAndDestroy(prv_uri8);

   398 	iTestHarness->EndTest(error);

   400 	//Testing 16-bit File URI componet extraction for private file on a removable media drive

   401 	iTestHarness->StartTestL(_L("Test Private File Uri Component Extraction (16-bit)"));

   402 	iTestHarness->LogIt(_L("FileName: %S; \n\t\tDrive:%c, \n\t\tFileStorageType:%D; \n\t\tPath:%S"), &aFileName, ('A' + aDrive), aFlags, &aPath);

   403 	CUri16* prv_uri16 = CUri16::CreatePrivateFileUriL(aFileName,aDrive,aFlags);

   404 	CleanupStack::PushL(prv_uri16);

   405 	error = DoFileUriComponentExtraction<TUriParser16, CUri16, TDesC16>(*prv_uri16, *fileUriScheme16, aPath, aExpectedFileName);

   406 	CleanupStack::PopAndDestroy(prv_uri16);

   407 	iTestHarness->EndTest(error);

   409 	CleanupStack::PopAndDestroy(2, fileUriScheme8); //fileUriScheme8, fileUriScheme16

   410 	}

   412 void CFileUriTest::TestFileUriCreationWithOldAPIAndComponentExtractionL(const TDesC16& aFileName, const TDesC16& aPath, const TDesC16& aExpectedFileName) const

   413 	{

   414 	//Testing File URI componet extraction created using CUri::NewLC()

   415 	iTestHarness->StartTestL(_L("Test File Uri Component Extraction created using NewLC (8-bit)"));

   416 	iTestHarness->LogIt(_L("FileName: %S; \n\t\tPath:%S"), &aFileName, &aPath);

   417 	TInt error = KErrNone;

   418 	HBufC8* fileUriScheme8 = HBufC8::NewLC(4);

   419 	TPtr8 fileUriScheme8Ptr = fileUriScheme8->Des();

   420 	fileUriScheme8Ptr.Copy(KFileUriScheme8);

   421 	HBufC* fileUriScheme16 = HBufC::NewLC(4);

   422 	TPtr16 fileUriScheme16Ptr = fileUriScheme16->Des();

   423 	fileUriScheme16Ptr.Copy(KFileUriScheme16);

   425 	_LIT8(KFileUri8, "file://%S");

   426 	HBufC8* path8 = EscapeUtils::ConvertFromUnicodeToUtf8L(aPath);

   427 	CleanupStack::PushL(path8);

   428 	HBufC8 *fileUri8 = HBufC8::NewLC((path8->Length()+10));

   429 	TPtr8 fileUri8Ptr = fileUri8->Des();

   430 	fileUri8Ptr.AppendFormat(KFileUri8,path8);

   431 	TUriParser8 urip8;

   432 	urip8.Parse(*fileUri8);

   433 	CUri8* _uri8 = CUri8::NewLC(urip8);

   434 	error = DoFileUriComponentExtraction<TUriParser8, CUri8, TDesC8>(*_uri8, *fileUriScheme8, *path8, aExpectedFileName);

   435 	CleanupStack::PopAndDestroy(_uri8);

   436 	iTestHarness->EndTest(error);

   438 	iTestHarness->StartTestL(_L("Test File Uri Component Extraction created using NewLC (16-bit)"));

   439 	iTestHarness->LogIt(_L("FileName: %S; \n\t\tFileStorageType:2; \n\t\tPath:%S"), &aFileName, &aPath);

   440 	HBufC *fileUri16 = EscapeUtils::ConvertToUnicodeFromUtf8L(*fileUri8);

   441 	CleanupStack::PushL(fileUri16);

   442 	TUriParser16 urip16;

   443 	urip16.Parse(*fileUri16);

   444 	CUri16* _uri16 = CUri16::NewLC(urip16);

   445 	error = DoFileUriComponentExtraction<TUriParser16, CUri16, TDesC16>(*_uri16, *fileUriScheme16, aPath, aExpectedFileName);

   446 	CleanupStack::PopAndDestroy(_uri16);

   447 	iTestHarness->EndTest(error);

   449 	CleanupStack::PopAndDestroy(5, fileUriScheme8); //fileUriScheme8, fileUriScheme16, path8, fileUri8, fileUri16

   450 	}

   452 //

   453 //

   454 //	Implementation of LOCAL functions

   455 //

   456 //

   457 template<class CUriType, class TDesCType>

   458 TInt DoFileUriExtraction(const CUriType& aUri, const TDesCType& aExpectedFileUri)

   459 	{

   460 	TInt error = 0;

   462 	// Check file URI...

   463 	error = aUri.Uri().UriDes().Compare(aExpectedFileUri);

   464 	if( error != 0 )

   465 		{

   466 		return error;

   467 		}

   468 	return KErrNone;

   469 	}

   471 template<class TUriParserType, class CUriType, class TDesCType, class TDesCType16>

   472 TInt DoFileUriComponentExtraction(const CUriType& aUri, const TDesCType& aScheme, const TDesCType& aPath, const TDesCType16& aExpectedFileName)

   473 	{

   474 	TUriParserType uriParser;

   475 	TInt error = uriParser.Parse(aUri.Uri().UriDes());

   476 	// Is this a valid Uri?

   477 	if( error == KUriUtilsErrInvalidUri )

   478 		{

   479 		return error;

   480 		}

   482 	// Check scheme...

   483 	if( (error = TestComponent(uriParser, aScheme, EUriScheme)) != 0 )

   484 		{

   485 		return error;

   486 		}

   488 	// Check path...

   489 	if( (error = TestComponent(uriParser, aPath, EUriPath)) != 0)

   490 		{

   491 		return error;

   492 		}

   494 	if (aExpectedFileName.Length() > 0)

   495 		{

   496 		HBufC* tmpFileName = uriParser.GetFileNameL();

   497 		error = tmpFileName->Compare(aExpectedFileName);

   498 		delete tmpFileName;

   499 		if (error != 0)

   500 			{

   501 			return error;

   502 			}

   503 		}

   505 	return KErrNone;

   506 	}

   508 template<class TParserType, class TDesCType, class TComponentType>

   509 TInt TestComponent(const TParserType& aParser, const TDesCType& aExpected, TComponentType aComponent)

   510 	{

   511 	return aParser.Extract(aComponent).Compare(aExpected);

   512 	}

   515 void CFileUriTest::TestFileUriNameExtractionL(const TDesC& aUri, const TDesC& aFilename, const TDesC& aPath)

   516 	{

   517 	TUriParser uriParser;

   518 	User::LeaveIfError(uriParser.Parse(aUri));

   520 	HBufC* name;

   521 	TInt error = KErrNone;

   523 	iTestHarness->StartTestL(_L("Test extract file name from URI (16 bit)"));

   524 	iTestHarness->LogIt(_L("URI: %S; \n\t\tExpected name:%S"), &uriParser.UriDes(), &aFilename);

   526 	name = uriParser.GetFileNameL(EUriFileNameTail);

   527 	iTestHarness->LogIt(_L("Computed name:%S"), name);

   528 	error = (aFilename.Compare(*name)==0) ? KErrNone : KErrBadName;

   529 	delete name;

   531 	iTestHarness->EndTest(error);

   533 	iTestHarness->StartTestL(_L("Test extract file path from URI (16 bit)"));

   534 	iTestHarness->LogIt(_L("URI: %S; \n\t\tExpected Path:%S"), &uriParser.UriDes(), &aPath);

   536 	name = uriParser.GetFileNameL(EUriFileNamePath);

   537 	iTestHarness->LogIt(_L("Computed Path:%S"), name);

   538 	error = (aPath.Compare(*name)==0) ? KErrNone : KErrBadName;

   539 	delete name;

   541 	iTestHarness->EndTest(error);

   542 	}

   544 void CFileUriTest::TestFileUriNameExtractionL(const TDesC8& aUri, const TDesC& aFilename, const TDesC& aPath)

   545 	{

   546 	TUriParser8 uriParser;

   547 	User::LeaveIfError(uriParser.Parse(aUri));

   549 	HBufC* name;

   550 	TInt error = KErrNone;

   552 	TFileName uri;

   553 	uri.Copy(uriParser.UriDes()); // safe for all valid URIs

   554 	iTestHarness->StartTestL(_L("Test extract file name from URI (8 bit)"));

   555 	iTestHarness->LogIt(_L("URI: %S; \n\t\tExpected name:%S"), &uri, &aFilename);

   557 	name = uriParser.GetFileNameL(EUriFileNameTail);

   558 	iTestHarness->LogIt(_L("Computed name:%S"), name);

   559 	error = (aFilename.Compare(*name)==0) ? KErrNone : KErrBadName;

   560 	delete name;

   562 	iTestHarness->EndTest(error);

   564 	iTestHarness->StartTestL(_L("Test extract file path from URI (8 bit)"));

   565 	iTestHarness->LogIt(_L("URI: %S; \n\t\tExpected Path:%S"), &uri, &aPath);

   567 	name = uriParser.GetFileNameL(EUriFileNamePath);

   568 	iTestHarness->LogIt(_L("Computed Path:%S"), name);

   569 	error = (aPath.Compare(*name)==0) ? KErrNone : KErrBadName;

   570 	delete name;

   572 	iTestHarness->EndTest(error);

   573 	}

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