1 // Copyright (c) 2007-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 //

    15 

    16 /**

    17  @file

    18  @test

    19  @internalComponent - Internal Symbian test code   

    20 */

    21 

    22 #include "sysmontesthelper.h"

    23 #include <f32file.h>

    24 #include <s32file.h>

    25 

    26 _LIT(KEIgnoreOnFailure, "EIgnoreOnFailure");

    27 _LIT(KERestartOS, "ERestartOS");

    28 _LIT(KERestartOSWithMode, "ERestartOSWithMode");

    29 

    30 EXPORT_C TRecoveryMethod CSysMonTestHelper::StringToRecoveryMethodL(const TDesC& aRecoveryMethodString)

    31 	{

    32 	if (aRecoveryMethodString == KEIgnoreOnFailure)

    33 		{

    34 		return EIgnoreOnFailure;

    35 		}

    36 	else if (aRecoveryMethodString == KERestartOS)

    37 		{

    38 		return ERestartOS;

    39 		}

    40 	else if (aRecoveryMethodString == KERestartOSWithMode)

    41 		{

    42 		return ERestartOSWithMode;

    43 		}

    44 	User::Leave(KErrArgument);

    45 	return EIgnoreOnFailure;

    46 	}

    47 		

    48 EXPORT_C CSysMonTestHelper* CSysMonTestHelper::NewLC()

    49 	{

    50 	CSysMonTestHelper* self = new(ELeave) CSysMonTestHelper();

    51 	CleanupStack::PushL(self);

    52 	self->ConstructL();

    53 	return self;

    54 	}

    55 

    56 EXPORT_C CSysMonTestHelper* CSysMonTestHelper::NewL()

    57 	{

    58 	CSysMonTestHelper* self = CSysMonTestHelper::NewLC();

    59 	CleanupStack::Pop(self);

    60 	return self;

    61 	}

    62 	

    63 EXPORT_C void CSysMonTestHelper::GetRecoveryMethodArgsL(TRecoveryMethod& aRecoveryMethod, TInt& aRecoveryMode)

    64 	{

    65 	aRecoveryMethod = CSysMonTestHelper::StringToRecoveryMethodL(iArgs->Arg(2));

    66 	TLex lex(iArgs->Arg(3));

    67 	User::LeaveIfError(lex.Val(aRecoveryMode));

    68 	}

    69 	

    70 EXPORT_C void CSysMonTestHelper::GetTimeoutArgL(TInt& aTimeout)

    71 	{

    72 	TLex lex(iArgs->Arg(2));

    73 	User::LeaveIfError(lex.Val(aTimeout));

    74 	}

    75 	

    76 EXPORT_C void CSysMonTestHelper::WriteResultL(const TInt& aResult)

    77 	{

    78 	RDebug::Print(_L("Result for %S: %d"), &iTestId, aResult);

    79 	TBuf<KMaxFileName> fileName;

    80 	fileName.Append(KResultsRoot);

    81 	fileName.Append(iTestId);

    82 	

    83 	RFs fs;

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

    85 	CleanupClosePushL(fs);

    86 	TInt err = fs.MkDirAll(KResultsRoot);

    87 	if (err != KErrAlreadyExists)

    88 		{

    89 		User::LeaveIfError(err);

    90 		}

    91 	

    92 	RFileWriteStream file;

    93 	file.PushL();

    94 	User::LeaveIfError(file.Replace(fs, fileName, EFileWrite));

    95 	file.WriteInt32L(aResult);

    96 	file.Close();

    97 	

    98 	CleanupStack::PopAndDestroy(2, &fs);

    99 	}

   100 	

   101 EXPORT_C void CSysMonTestHelper::WriteDeregResultL(const TInt& aResult)

   102 	{

   103 	RDebug::Print(_L("Dereg Result for %S: %d"), &iTestId, aResult);

   104 	TBuf<KMaxFileName> fileName;

   105 	fileName.Append(KResultsRootDereg);

   106 	fileName.Append(iTestId);

   107 	

   108 	RFs fs;

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

   110 	CleanupClosePushL(fs);

   111 	TInt err = fs.MkDirAll(KResultsRoot);

   112 	if (err != KErrAlreadyExists)

   113 		{

   114 		User::LeaveIfError(err);

   115 		}

   116 	

   117 	RFileWriteStream file;

   118 	file.PushL();

   119 	User::LeaveIfError(file.Replace(fs, fileName, EFileWrite));

   120 	file.WriteInt32L(aResult);

   121 	file.Close();

   122 	

   123 	CleanupStack::PopAndDestroy(2, &fs);

   124 	}

   125 	

   126 EXPORT_C void CSysMonTestHelper::GetResultIntL(const TDesC& aTestId, TInt& aResult)

   127 	{

   128 	TBuf<KMaxFileName> fileName;

   129 	fileName.Append(KResultsRoot);

   130 	fileName.Append(aTestId);

   131 	

   132 	RFs fs;

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

   134 	CleanupClosePushL(fs);

   135 	

   136 	RFileReadStream file;

   137 	file.PushL();

   138 	User::LeaveIfError(file.Open(fs, fileName, EFileRead));

   139 	aResult = file.ReadInt32L();

   140 	file.Close();

   141 	

   142 	CleanupStack::PopAndDestroy(2, &fs);

   143 	}

   144 	

   145 EXPORT_C void CSysMonTestHelper::GetDeregResultIntL(const TDesC& aTestId, TInt& aResult)

   146 	{

   147 	TBuf<KMaxFileName> fileName;

   148 	fileName.Append(KResultsRootDereg);

   149 	fileName.Append(aTestId);

   150 	

   151 	RFs fs;

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

   153 	CleanupClosePushL(fs);

   154 	

   155 	RFileReadStream file;

   156 	file.PushL();

   157 	User::LeaveIfError(file.Open(fs, fileName, EFileRead));

   158 	aResult = file.ReadInt32L();

   159 	file.Close();

   160 	

   161 	CleanupStack::PopAndDestroy(2, &fs);

   162 	}

   163 	

   164 EXPORT_C TInt CSysMonTestHelper::ReadRunCountL(const TDesC& aProcessFilename)

   165 	{

   166 	RFs fs;

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

   168 	CleanupClosePushL(fs);

   169 	

   170 	TParse parse;

   171 	fs.Parse(aProcessFilename, parse);

   172 	

   173 	TBuf<KMaxFileName> fileName;

   174 	fileName.Append(KRunCountsRoot);

   175 	fileName.Append(parse.NameAndExt());

   176 	fileName.Append(KTxtExtension);

   177 

   178 	RFileReadStream file;

   179 	TInt err = 0;

   180 	err = file.Open(fs, fileName, EFileRead);

   181 	TInt result = 0;

   182 	if (err == KErrNotFound || err == KErrPathNotFound)

   183 		{

   184 		CleanupStack::PopAndDestroy(&fs);

   185 		}

   186 	else

   187 		{

   188 		file.PushL();

   189 		User::LeaveIfError(err);

   190 		result = file.ReadInt32L();

   191 		file.Close();

   192 		CleanupStack::PopAndDestroy(2, &fs);

   193 		}

   194 	RDebug::Print(_L("Number of previous runs for %S : %d"), &aProcessFilename, result);

   195 	return result;

   196 	}

   197 	

   198 EXPORT_C void CSysMonTestHelper::IncrementRunCountL(const TDesC& aProcessFilename)

   199 	{

   200 	TInt runcount = ReadRunCountL(aProcessFilename);

   201 	runcount++;

   202 

   203 	RFs fs;

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

   205 	CleanupClosePushL(fs);

   206 	

   207 	TParse parse;

   208 	fs.Parse(aProcessFilename, parse);

   209 	

   210 	TBuf<KMaxFileName> fileName;

   211 	fileName.Append(KRunCountsRoot);

   212 	fileName.Append(parse.NameAndExt());

   213 	fileName.Append(KTxtExtension);

   214 

   215 	TInt err = fs.MkDirAll(KRunCountsRoot);

   216 	if (err != KErrAlreadyExists)

   217 		{

   218 		User::LeaveIfError(err);

   219 		}

   220 

   221 	RFileWriteStream file;

   222 	User::LeaveIfError(file.Replace(fs, fileName, EFileWrite));

   223 	file.PushL();

   224 	file.WriteInt32L(runcount);

   225 	file.Close();

   226 

   227 	RDebug::Print(_L("New runcount for %S : %d"), &aProcessFilename, runcount);

   228 	

   229 	CleanupStack::PopAndDestroy(2, &fs);

   230 	}

   231 	

   232 EXPORT_C TInt CSysMonTestHelper::GetRestartCountL()

   233 	{

   234 	RFs fs;

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

   236 	CleanupClosePushL(fs);

   237 	

   238 	RFile file;

   239 	TInt err = 0;

   240 	err = file.Open(fs, KRestartCountFile, EFileRead);

   241 	TInt result = 0;

   242 	if (err == KErrNotFound || err == KErrPathNotFound)

   243 		{

   244 		CleanupStack::PopAndDestroy(&fs);

   245 		}

   246 	else

   247 		{

   248 		CleanupClosePushL(file);

   249 		User::LeaveIfError(err);

   250 		TBuf8<8> content;

   251 		file.Read(content);

   252 		content.Delete(0,6);

   253 		TLex8 myLex(content);

   254 		User::LeaveIfError(myLex.Val(result));

   255 		file.Close();

   256 		CleanupStack::PopAndDestroy(2, &fs);

   257 		}

   258 	return result;

   259 	}

   260 

   261 EXPORT_C TInt CSysMonTestHelper::GetRegisterCountL()

   262 	{

   263 	RFs fs;

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

   265 	CleanupClosePushL(fs);

   266 	

   267 	RFile file;

   268 	TInt err = 0;

   269 	err = file.Open(fs, KRegisterCountFile, EFileRead);

   270 	TInt result = 0;

   271 	if (err == KErrNotFound || err == KErrPathNotFound)

   272 		{

   273 		CleanupStack::PopAndDestroy(&fs);

   274 		}

   275 	else

   276 		{

   277 		CleanupClosePushL(file);

   278 		User::LeaveIfError(err);

   279 		TBuf8<11> content;

   280 		file.Read(content);

   281 		content.Delete(0,9);

   282 		TLex8 myLex(content);

   283 		User::LeaveIfError(myLex.Val(result));

   284 		file.Close();

   285 		CleanupStack::PopAndDestroy(2, &fs);

   286 		}

   287 	return result;

   288 	}

   289 	

   290 EXPORT_C void CSysMonTestHelper::GetTestId(TDes& aTestId)

   291 	{

   292 	aTestId = iTestId;

   293 	}

   294 	

   295 EXPORT_C void CSysMonTestHelper::TestErrorcodeL(TInt& aErrorcode)

   296 	{

   297 	if (aErrorcode != KErrNone)

   298 		{

   299 		this->WriteResultL(aErrorcode);

   300 		this->WriteDeregResultL(aErrorcode);

   301 		User::Leave(aErrorcode);

   302 		}

   303 	}

   304 	

   305 void CSysMonTestHelper::ConstructL()

   306 	{

   307 	iArgs = CCommandLineArguments::NewL();

   308 	iTestId = TBufC<KMaxTestIdLength>(iArgs->Arg(1));

   309 	}

   310 	

   311 CSysMonTestHelper::CSysMonTestHelper()

   312 	{}

   313 	

   314 EXPORT_C CSysMonTestHelper::~CSysMonTestHelper()

   315 	{

   316 	delete iArgs;

   317 	}