1 /*

     2 * Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 #include "tbackuprestorestep.h"

    20 #include <test/testexecutelog.h>

    21 

    22 #include <f32file.h>

    23 

    24 _LIT(KMetaDataFileName, "\\tswi\\tbackuprestore\\metadata%x");

    25 _LIT(KBackupFileName, "\\tswi\\tbackuprestore\\backup%x.%u");

    26 

    27 _LIT(KExpectedResultKeyFormat, "expectedresult%d");

    28 const TInt KResultKeyMaxLength = 16;

    29 const TInt KResultKeyMaxNum = 99;

    30 

    31 

    32 CTBackupRestoreStepBase::~CTBackupRestoreStepBase()

    33 	{

    34 	iFs.Close();

    35 	}

    36 

    37 CTBackupRestoreStepBase::CTBackupRestoreStepBase()

    38 	{

    39 	}

    40 

    41 TVerdict CTBackupRestoreStepBase::doTestStepPreambleL()

    42 	{

    43 	User::LeaveIfError(iFs.Connect());

    44 	SetTestStepResult(EPass);

    45 	return TestStepResult();

    46 	}

    47 

    48 TVerdict CTBackupRestoreStepBase::doTestStepPostambleL()

    49 	{

    50 	return TestStepResult();

    51 	}

    52 

    53 TBool CTBackupRestoreStepBase::Exists(TPtrC aFileName)

    54 	{

    55 	TEntry entry;

    56 	TInt err = iFs.Entry(aFileName, entry);

    57 	INFO_PRINTF3(_L("Entry of %S returned %d"), &aFileName, err);

    58 	return err == KErrNone;

    59 	}

    60 	

    61 TBool CTBackupRestoreStepBase::ModifyFile()

    62 	{

    63 	TBuf<20> token;

    64 	token.Format(_L("MODIFY%d.%d"), iCurrentPackageNumber, iCurrentFileNumber);

    65 	TInt doIt = 0;

    66 	TBool found = GetIntFromConfig(ConfigSection(),token, doIt);

    67 	return (found && doIt != 0);

    68 	}

    69 

    70 void CTBackupRestoreStepBase::CopyFileL(TPtrC aSourceFileName, TPtrC aDestFileName)

    71 	{

    72 	INFO_PRINTF3(_L("Copy %S to %S"), &aSourceFileName, &aDestFileName);

    73 	RFile infile;

    74 	RFile outfile;

    75 	User::LeaveIfError(infile.Open(iFs,aSourceFileName,EFileRead));

    76 	CleanupClosePushL(infile);

    77 	if (KErrNone != outfile.Create(iFs,aDestFileName,EFileWrite))

    78 		{

    79 		User::LeaveIfError(outfile.Open(iFs, aDestFileName, EFileWrite));

    80 		}

    81 		

    82 	CleanupClosePushL(outfile);

    83 	

    84 	HBufC8* buffer = HBufC8::NewLC(1024);

    85 	TPtr8 ptr = buffer->Des();

    86 	

    87 	User::LeaveIfError(infile.Read(ptr));

    88 	while(ptr.Length() != 0)

    89 		{

    90 		User::LeaveIfError(outfile.Write(*buffer));

    91 		User::LeaveIfError(infile.Read(ptr));

    92 		}

    93 	

    94 	CleanupStack::PopAndDestroy(3, &infile); // buffer, outfile

    95 	}

    96 

    97 TBool CTBackupRestoreStepBase::NextPackage()

    98 	{

    99 	iCurrentPackageNumber++;

   100 	iCurrentFileNumber=0;

   101 	iDataFileNumber=0;

   102 	if (PackageUID().iUid != 0)

   103 		{

   104 		INFO_PRINTF2(_L("Package %d"), iCurrentPackageNumber);

   105 		return ETrue;

   106 		}

   107 	return EFalse;

   108 	}

   109 

   110 TUid CTBackupRestoreStepBase::PackageUID()

   111 	{

   112 	TUid uid;

   113 	TInt tmp;

   114 	TBuf<20> token;

   115 	token.Format(_L("UID%d"), iCurrentPackageNumber);

   116 	if(GetHexFromConfig(ConfigSection(),token, tmp) == EFalse)

   117 		{

   118 		tmp = 0;

   119 		}

   120 	uid.iUid = tmp;

   121 	return uid;

   122 	}

   123 

   124 TBool CTBackupRestoreStepBase::NextFile()

   125 	{

   126 	iCurrentFileNumber++;

   127 	if (InstalledFileName().Length() != 0)

   128 		{

   129 		INFO_PRINTF2(_L("File %d"), iCurrentFileNumber);

   130 		return ETrue;

   131 		}

   132 	return EFalse;

   133 	}

   134 	

   135 TBool CTBackupRestoreStepBase::NextDataFile()

   136 	{

   137 	iDataFileNumber++;

   138 	if (DataFileName().Length() != 0)

   139 		{

   140 		return ETrue;

   141 		}

   142 	return EFalse;

   143 	}

   144 

   145 TPtrC CTBackupRestoreStepBase::SISFileNameL()

   146 	{

   147 	TBuf<20> token;

   148 	token.Format(_L("SIS%d"), iCurrentPackageNumber);

   149 	TPtrC sisfile;

   150 	if (GetStringFromConfig(ConfigSection(),token, sisfile) == EFalse)

   151 		{

   152 		User::Leave(KErrNotFound);

   153 		}

   154 	return sisfile;

   155 	}

   156 

   157 TPtrC CTBackupRestoreStepBase::WrongInstalledFileName()

   158 	{

   159 	TBuf<20> token;

   160 	token.Format(_L("WrongFile%d.%d"), iCurrentPackageNumber, iCurrentFileNumber);

   161 	TPtrC filename;

   162 	GetStringFromConfig(ConfigSection(),token, filename);

   163 	return filename;

   164 	}

   165 

   166 TPtrC CTBackupRestoreStepBase::InstalledFileName()

   167 	{

   168 	TBuf<20> token;

   169 	token.Format(_L("FILE%d.%d"), iCurrentPackageNumber, iCurrentFileNumber);

   170 	TPtrC filename;

   171 	GetStringFromConfig(ConfigSection(),token, filename);

   172 	return filename;

   173 	}

   174 

   175 TPtrC CTBackupRestoreStepBase::DataFileName()

   176 	{

   177 	TBuf<20> token;

   178 	token.Format(_L("DATA%d.%d"), iCurrentPackageNumber, iDataFileNumber);

   179 	TPtrC filename;

   180 	GetStringFromConfig(ConfigSection(),token, filename);

   181 	return filename;

   182 	}

   183 

   184 

   185 

   186 TFileName CTBackupRestoreStepBase::BackupFileName()

   187 	{

   188 	TFileName backupFileName;

   189 	TDriveUnit sysDrive(RFs::GetSystemDrive());

   190 	TBuf<128> fileName = sysDrive.Name();

   191 	fileName.Append(KBackupFileName);

   192 	backupFileName.Format(fileName, PackageUID().iUid, iCurrentFileNumber);

   193 	return backupFileName;

   194 	}

   195 	

   196 void CTBackupRestoreStepBase::TouchL(const TDesC& aFileName)

   197 	{

   198 	iFs.MkDirAll(aFileName);

   199 	RFile file;

   200 	TRAP_IGNORE(file.Replace(iFs, aFileName, EFileWrite));

   201 	file.Close();

   202 	}

   203 

   204 void CTBackupRestoreStepBase::WriteMetaDataL(HBufC8* aMetaData)

   205 	{

   206 	RFile metadatafile;

   207 	TBuf<256> metadataFileName;

   208 	TDriveUnit sysDrive(RFs::GetSystemDrive());

   209 	TBuf<128> fileName = sysDrive.Name();

   210 	fileName.Append(KMetaDataFileName);

   211 	metadataFileName.Format(fileName, PackageUID().iUid);

   212 

   213 	User::LeaveIfError(metadatafile.Replace(iFs, metadataFileName, EFileWrite));

   214 	

   215 	CleanupClosePushL(metadatafile);

   216 	User::LeaveIfError(metadatafile.Write(*aMetaData));

   217 	CleanupStack::PopAndDestroy(&metadatafile);

   218 	}

   219 

   220 HBufC8*	CTBackupRestoreStepBase::ReadMetaDataL(TInt aBytesToCrop)

   221 	{

   222 	RFile metadatafile;

   223 	TBuf<256> metadataFileName;

   224 	TDriveUnit sysDrive(RFs::GetSystemDrive());

   225 	TBuf<128> fileName = sysDrive.Name();

   226 	fileName.Append(KMetaDataFileName);

   227 	metadataFileName.Format(fileName, PackageUID().iUid);

   228 

   229 	User::LeaveIfError(metadatafile.Open(iFs, metadataFileName, EFileRead));

   230 	CleanupClosePushL(metadatafile);

   231 	

   232 	TInt length(0);

   233 	metadatafile.Seek(ESeekEnd,length);

   234 	length -= aBytesToCrop;

   235 	TInt dummy(0);

   236 	metadatafile.Seek(ESeekStart,dummy);

   237 	

   238 	HBufC8* metadata = HBufC8::NewL(length);

   239 	TPtr8 ptr = metadata->Des();

   240 	TInt err = metadatafile.Read(ptr, length);

   241 	if (err != KErrNone)

   242 		{

   243 		delete metadata;

   244 		User::Leave(err);

   245 		}

   246 	CleanupStack::PopAndDestroy(&metadatafile);

   247 	return metadata;

   248 	}

   249 

   250 TInt CTBackupRestoreStepBase::MetaDataCropLength()

   251 	{

   252 	TInt cropLength(0);

   253 	TBuf<24> token;

   254 	token.Format(_L("METADATACROPBYTES%d"), iCurrentPackageNumber);

   255 	if(GetIntFromConfig(ConfigSection(),token, cropLength))

   256 		{

   257 		INFO_PRINTF3(_L("Ignoring last %d bytes from metadata for package %d."),

   258 						cropLength, iCurrentPackageNumber);

   259 		}

   260 	return cropLength;	

   261 	}

   262 

   263 TChar CTBackupRestoreStepBase::ExpectedDriveL()

   264 	{

   265 	TBuf<20> token;

   266 	token.Format(_L("INSTALLDRIVE%d"), iCurrentPackageNumber);

   267 	TPtrC driveString;

   268 	if (GetStringFromConfig(ConfigSection(),token, driveString) == EFalse)

   269 		{

   270 		User::Leave(KErrNotFound);

   271 		}

   272 	TChar sisDrive(0);

   273 	if (driveString.Length() > 0)

   274 		{

   275 		sisDrive = driveString[0];

   276 		}

   277 	return sisDrive;

   278 	}

   279 

   280 

   281 void CTBackupRestoreStepBase::CheckExpectedResultCodesL()

   282 	{

   283 	RArray<TInt> expectedResultCodes;

   284 	CleanupClosePushL(expectedResultCodes);

   285 	TInt result = KErrNone;

   286 	TBuf<KResultKeyMaxLength> resultKey;

   287 	TBool found = ETrue;

   288 

   289 	for (TInt i = 1; i <= KResultKeyMaxNum && found; i++)

   290 		{

   291 		resultKey.Format(KExpectedResultKeyFormat, i);

   292 		found = GetIntFromConfig(ConfigSection(), resultKey, result);

   293 		if (found)

   294 			{

   295 			INFO_PRINTF2(_L("Acceptable result code %d"), result);

   296 			TInt err = expectedResultCodes.InsertInOrder(result);

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

   298 				{

   299 				User::Leave(err);

   300 				}

   301 			}

   302 		}

   303 

   304 	if (expectedResultCodes.Count() > 0)

   305 		{

   306 		// A result code matching one of the possible expected results will

   307 		// be converted to EPass, otherwise the result will be EFail.

   308 		if (expectedResultCodes.FindInOrder(TestStepResult()) == KErrNotFound)

   309 			{

   310 			ERR_PRINTF2(_L("Result code %d is not expected"), TestStepResult());

   311 			SetTestStepResult(EFail);

   312 			}

   313 		else

   314 			{

   315 			INFO_PRINTF2(_L("Result code %d is in accepted list"), TestStepResult());

   316 			SetTestStepResult(EPass);

   317 			}

   318 		}

   319 	CleanupStack::PopAndDestroy(&expectedResultCodes);

   320 	}

   321 

   322 

   323 

   324