os/persistentdata/traceservices/commsdebugutility/TE_commsdebugutility/src/step_030_xx.cpp
1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/traceservices/commsdebugutility/TE_commsdebugutility/src/step_030_xx.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,3042 @@
1.4 +// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +// See the test specification for details of what these test cases do.
1.18 +#include "teststepcomsdbg.h"
1.19 +#include "TestMessage.h"
1.20 +#include "step_030_xx.h"
1.21 +
1.22 +
1.23 +#include <comms-infras/commsdebugutility.h>
1.24 +
1.25 +
1.26 +
1.27 +/**
1.28 +* This is the Constructor
1.29 +*/
1.30 +
1.31 +
1.32 +CFloggerTest030_Tag_Setup::CFloggerTest030_Tag_Setup()
1.33 + {
1.34 + // Store the name of this test case
1.35 + SetTestStepName(_L("step_030_Tag_Setup"));
1.36 + }
1.37 +
1.38 +
1.39 +/**
1.40 +* This is the Destructor
1.41 +*/
1.42 +
1.43 +
1.44 +CFloggerTest030_Tag_Setup::~CFloggerTest030_Tag_Setup()
1.45 + {
1.46 + }
1.47 +
1.48 +
1.49 +/**
1.50 +* This function returns whether the test case has
1.51 +* passed or failed
1.52 +*/
1.53 +
1.54 +
1.55 +TVerdict CFloggerTest030_Tag_Setup::doTestStepL( )
1.56 + {
1.57 + if ( executeStepL() == KErrNone )
1.58 + SetTestStepResult(EPass);
1.59 +
1.60 + else
1.61 + SetTestStepResult(EFail);
1.62 +
1.63 + //INFO_PRINTF1(_L("leaving Step 030_Tag_Setup "));
1.64 + User::After(KTimeForDisplay);
1.65 +
1.66 +
1.67 + return TestStepResult();
1.68 + }
1.69 +
1.70 +
1.71 +TInt CFloggerTest030_Tag_Setup::executeStepL(TBool)
1.72 + {
1.73 + return KErrGeneral;
1.74 + }
1.75 +
1.76 +TInt CFloggerTest030_Tag_Setup::executeStepL()
1.77 + {
1.78 + return constructFloggerIniL(KTagTestsIniFileSettings);
1.79 + }
1.80 +
1.81 +
1.82 +
1.83 +
1.84 +
1.85 +/**
1.86 +* 030_TagSetLogTag01: Test that flogger handles empty tags
1.87 +*/
1.88 +
1.89 +CFloggerTest030_TagSetLogTag01::CFloggerTest030_TagSetLogTag01()
1.90 + {
1.91 + // Store the name of this test case
1.92 + SetTestStepName(_L("step_030_TagSetLogTag01"));
1.93 + }
1.94 +
1.95 +
1.96 +
1.97 +
1.98 +CFloggerTest030_TagSetLogTag01::~CFloggerTest030_TagSetLogTag01()
1.99 + {
1.100 + }
1.101 +
1.102 +
1.103 +
1.104 +
1.105 +TVerdict CFloggerTest030_TagSetLogTag01::doTestStepL( )
1.106 + {
1.107 + if ( executeStepL() == KErrNone )
1.108 + SetTestStepResult(EPass);
1.109 +
1.110 + else
1.111 + SetTestStepResult(EFail);
1.112 +
1.113 + User::After(KTimeForDisplay);
1.114 +
1.115 +
1.116 + return TestStepResult();
1.117 + }
1.118 +
1.119 +TInt CFloggerTest030_TagSetLogTag01::executeStepL(TBool)
1.120 + {
1.121 + return KErrGeneral;
1.122 + }
1.123 +
1.124 +
1.125 +TInt CFloggerTest030_TagSetLogTag01::executeStepL()
1.126 + {
1.127 +
1.128 + TInt ret ;
1.129 + RFileLogger theFlogger;
1.130 + ret = theFlogger.Connect();
1.131 +
1.132 + if ( ret == KErrNone)
1.133 + {
1.134 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.135 + theFlogger.ClearLog();
1.136 + theFlogger.SetLogTags(KNullDesC8, KNullDesC8);
1.137 + theFlogger.Write(KTestMessage);
1.138 + theFlogger.Close();
1.139 + User::After(KTimeToLog);
1.140 + TRAPD(r, ret = DoTestCheckWriteL());
1.141 + if (r != KErrNone)
1.142 + ret = r;
1.143 + }
1.144 +
1.145 + return ret;
1.146 +
1.147 + }
1.148 +
1.149 +
1.150 +
1.151 +
1.152 +TInt CFloggerTest030_TagSetLogTag01::DoTestCheckWriteL()
1.153 + {
1.154 + RFile theFile;
1.155 + HBufC8 * hBuffer;
1.156 + TInt listfilesize,returnCode;
1.157 + RFs fileSystem; //For file operation create a file system
1.158 + TUint numSuccessful = 0;
1.159 +
1.160 +
1.161 + User::LeaveIfError(fileSystem.Connect());
1.162 + CleanupClosePushL(fileSystem);
1.163 +
1.164 + //Open the file in the read mode
1.165 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.166 +
1.167 + CleanupClosePushL(theFile);
1.168 +
1.169 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.170 +
1.171 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.172 + CleanupStack::PushL(hBuffer);
1.173 +
1.174 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.175 +
1.176 + // Read from position 0: start of file
1.177 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.178 +
1.179 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.180 + //from the file
1.181 +
1.182 + if (returnCode == KErrNotFound)
1.183 + {
1.184 + numSuccessful++;
1.185 + returnCode = ptrString.Find(KErrOOM);
1.186 + if (returnCode > 0)
1.187 + User::Leave(KErrNoMemory);
1.188 + }
1.189 +
1.190 +
1.191 + CleanupStack::PopAndDestroy(hBuffer);
1.192 + CleanupStack::PopAndDestroy(); //theFile
1.193 + CleanupStack::PopAndDestroy(); //fileSystem
1.194 +
1.195 + if (numSuccessful == 1)
1.196 + return KErrNone;
1.197 + else
1.198 + return KErrNotFound;
1.199 + }
1.200 +
1.201 +
1.202 +
1.203 +
1.204 +/**
1.205 +* 030_TagSetLogTag02: Test that flogger handles empty subsys tag
1.206 +*/
1.207 +
1.208 +CFloggerTest030_TagSetLogTag02::CFloggerTest030_TagSetLogTag02()
1.209 + {
1.210 + // Store the name of this test case
1.211 + SetTestStepName(_L("step_030_TagSetLogTag02"));
1.212 + }
1.213 +
1.214 +
1.215 +
1.216 +
1.217 +CFloggerTest030_TagSetLogTag02::~CFloggerTest030_TagSetLogTag02()
1.218 + {
1.219 + }
1.220 +
1.221 +
1.222 +
1.223 +
1.224 +TVerdict CFloggerTest030_TagSetLogTag02::doTestStepL( )
1.225 + {
1.226 + if ( executeStepL() == KErrNone )
1.227 + SetTestStepResult(EPass);
1.228 +
1.229 + else
1.230 + SetTestStepResult(EFail);
1.231 +
1.232 + User::After(KTimeForDisplay);
1.233 +
1.234 +
1.235 + return TestStepResult();
1.236 + }
1.237 +
1.238 +
1.239 +TInt CFloggerTest030_TagSetLogTag02::executeStepL(TBool)
1.240 + {
1.241 + return KErrGeneral;
1.242 + }
1.243 +
1.244 +TInt CFloggerTest030_TagSetLogTag02::executeStepL()
1.245 + {
1.246 +
1.247 + TInt ret ;
1.248 + RFileLogger theFlogger;
1.249 + ret = theFlogger.Connect();
1.250 +
1.251 + if ( ret == KErrNone)
1.252 + {
1.253 + //Create Log by passing the subsystem and component name as parameters
1.254 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.255 + theFlogger.ClearLog();
1.256 + theFlogger.SetLogTags(KNullDesC8, KStdCompTag8);
1.257 + theFlogger.Write(KTestMessage);
1.258 + theFlogger.Close();
1.259 + User::After(KTimeToLog);
1.260 + TRAPD(r, ret = DoTestCheckWriteL());
1.261 + if (r != KErrNone)
1.262 + ret = r;
1.263 + }
1.264 +
1.265 + return ret;
1.266 +
1.267 + }
1.268 +
1.269 +
1.270 +
1.271 +
1.272 +TInt CFloggerTest030_TagSetLogTag02::DoTestCheckWriteL()
1.273 + {
1.274 + RFile theFile;
1.275 + HBufC8 * hBuffer;
1.276 + TInt listfilesize,returnCode;
1.277 + RFs fileSystem; //For file operation create a file system
1.278 + TUint numSuccessful = 0;
1.279 +
1.280 +
1.281 + User::LeaveIfError(fileSystem.Connect());
1.282 + CleanupClosePushL(fileSystem);
1.283 +
1.284 + //Open the file in the read mode
1.285 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.286 +
1.287 + CleanupClosePushL(theFile);
1.288 +
1.289 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.290 +
1.291 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.292 + CleanupStack::PushL(hBuffer);
1.293 +
1.294 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.295 +
1.296 + // Read from position 0: start of file
1.297 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.298 +
1.299 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.300 + //from the file
1.301 +
1.302 + if (returnCode == KErrNotFound)
1.303 + {
1.304 + numSuccessful++;
1.305 + returnCode = ptrString.Find(KErrOOM);
1.306 + if (returnCode > 0)
1.307 + User::Leave(KErrNoMemory);
1.308 + }
1.309 +
1.310 +
1.311 + CleanupStack::PopAndDestroy(hBuffer);
1.312 + CleanupStack::PopAndDestroy(); //theFile
1.313 + CleanupStack::PopAndDestroy(); //fileSystem
1.314 +
1.315 + if (numSuccessful == 1)
1.316 + return KErrNone;
1.317 + else
1.318 + return KErrNotFound;
1.319 + }
1.320 +
1.321 +
1.322 +
1.323 +/**
1.324 +* 030_TagSetLogTag03: Test that flogger handles empty component tag
1.325 +*/
1.326 +
1.327 +CFloggerTest030_TagSetLogTag03::CFloggerTest030_TagSetLogTag03()
1.328 + {
1.329 + // Store the name of this test case
1.330 + SetTestStepName(_L("step_030_TagSetLogTag03"));
1.331 + }
1.332 +
1.333 +
1.334 +
1.335 +
1.336 +CFloggerTest030_TagSetLogTag03::~CFloggerTest030_TagSetLogTag03()
1.337 + {
1.338 + }
1.339 +
1.340 +
1.341 +
1.342 +
1.343 +TVerdict CFloggerTest030_TagSetLogTag03::doTestStepL( )
1.344 + {
1.345 + if ( executeStepL() == KErrNone )
1.346 + SetTestStepResult(EPass);
1.347 +
1.348 + else
1.349 + SetTestStepResult(EFail);
1.350 +
1.351 + User::After(KTimeForDisplay);
1.352 +
1.353 +
1.354 + return TestStepResult();
1.355 + }
1.356 +
1.357 +TInt CFloggerTest030_TagSetLogTag03::executeStepL(TBool)
1.358 + {
1.359 + return KErrGeneral;
1.360 + }
1.361 +
1.362 +
1.363 +TInt CFloggerTest030_TagSetLogTag03::executeStepL()
1.364 + {
1.365 +
1.366 + TInt ret ;
1.367 + RFileLogger theFlogger;
1.368 + ret = theFlogger.Connect();
1.369 +
1.370 + if ( ret == KErrNone)
1.371 + {
1.372 + //Create Log by passing the subsystem and component name as parameters
1.373 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.374 + theFlogger.ClearLog();
1.375 + theFlogger.SetLogTags(KStdSubsysTag8, KNullDesC8);
1.376 + theFlogger.Write(KTestMessage);
1.377 + theFlogger.Close();
1.378 + User::After(KTimeToLog);
1.379 + TRAPD(r, ret = DoTestCheckWriteL());
1.380 + if (r != KErrNone)
1.381 + ret = r;
1.382 + }
1.383 +
1.384 + return ret;
1.385 +
1.386 + }
1.387 +
1.388 +
1.389 +
1.390 +
1.391 +TInt CFloggerTest030_TagSetLogTag03::DoTestCheckWriteL()
1.392 + {
1.393 + RFile theFile;
1.394 + HBufC8 * hBuffer;
1.395 + TInt listfilesize,returnCode;
1.396 + RFs fileSystem; //For file operation create a file system
1.397 + TUint numSuccessful = 0;
1.398 +
1.399 +
1.400 + User::LeaveIfError(fileSystem.Connect());
1.401 + CleanupClosePushL(fileSystem);
1.402 +
1.403 + //Open the file in the read mode
1.404 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.405 +
1.406 + CleanupClosePushL(theFile);
1.407 +
1.408 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.409 +
1.410 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.411 + CleanupStack::PushL(hBuffer);
1.412 +
1.413 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.414 +
1.415 + // Read from position 0: start of file
1.416 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.417 +
1.418 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.419 + //from the file
1.420 +
1.421 + if (returnCode == KErrNotFound)
1.422 + {
1.423 + numSuccessful++;
1.424 + returnCode = ptrString.Find(KErrOOM);
1.425 + if (returnCode > 0)
1.426 + User::Leave(KErrNoMemory);
1.427 + }
1.428 +
1.429 +
1.430 + CleanupStack::PopAndDestroy(hBuffer);
1.431 + CleanupStack::PopAndDestroy(); //theFile
1.432 + CleanupStack::PopAndDestroy(); //fileSystem
1.433 +
1.434 + if (numSuccessful == 1)
1.435 + return KErrNone;
1.436 + else
1.437 + return KErrNotFound;
1.438 + }
1.439 +
1.440 +
1.441 +
1.442 +
1.443 +/**
1.444 +* 030_TagSetLogTag04: Test that flogger handles spaces in tags
1.445 +*/
1.446 +
1.447 +CFloggerTest030_TagSetLogTag04::CFloggerTest030_TagSetLogTag04()
1.448 + {
1.449 + // Store the name of this test case
1.450 + SetTestStepName(_L("step_030_TagSetLogTag04"));
1.451 + }
1.452 +
1.453 +
1.454 +
1.455 +
1.456 +CFloggerTest030_TagSetLogTag04::~CFloggerTest030_TagSetLogTag04()
1.457 + {
1.458 + }
1.459 +
1.460 +
1.461 +
1.462 +
1.463 +TVerdict CFloggerTest030_TagSetLogTag04::doTestStepL( )
1.464 + {
1.465 + if ( executeStepL() == KErrNone )
1.466 + SetTestStepResult(EPass);
1.467 +
1.468 + else
1.469 + SetTestStepResult(EFail);
1.470 +
1.471 + User::After(KTimeForDisplay);
1.472 +
1.473 +
1.474 + return TestStepResult();
1.475 + }
1.476 +
1.477 +
1.478 +TInt CFloggerTest030_TagSetLogTag04::executeStepL(TBool)
1.479 + {
1.480 + return KErrGeneral;
1.481 + }
1.482 +
1.483 +TInt CFloggerTest030_TagSetLogTag04::executeStepL()
1.484 + {
1.485 +
1.486 + TInt ret ;
1.487 + RFileLogger theFlogger;
1.488 + ret = theFlogger.Connect();
1.489 +
1.490 + if ( ret == KErrNone)
1.491 + {
1.492 + //Create Log by passing the subsystem and component name as parameters
1.493 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.494 + theFlogger.ClearLog();
1.495 + theFlogger.SetLogTags(KStdSubsysTag8, KCompTagWithSpaceChars8);
1.496 + theFlogger.Write(KTestMessage);
1.497 + theFlogger.Close();
1.498 + User::After(KTimeToLog);
1.499 + TRAPD(r, ret = DoTestCheckWriteL());
1.500 + if (r != KErrNone)
1.501 + ret = r;
1.502 + }
1.503 +
1.504 + return ret;
1.505 +
1.506 + }
1.507 +
1.508 +
1.509 +
1.510 +
1.511 +TInt CFloggerTest030_TagSetLogTag04::DoTestCheckWriteL()
1.512 + {
1.513 + RFile theFile;
1.514 + HBufC8 * hBuffer;
1.515 + TInt listfilesize,returnCode;
1.516 + RFs fileSystem; //For file operation create a file system
1.517 + TUint numSuccessful = 0;
1.518 +
1.519 +
1.520 + User::LeaveIfError(fileSystem.Connect());
1.521 + CleanupClosePushL(fileSystem);
1.522 +
1.523 + //Open the file in the read mode
1.524 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.525 +
1.526 + CleanupClosePushL(theFile);
1.527 +
1.528 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.529 +
1.530 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.531 + CleanupStack::PushL(hBuffer);
1.532 +
1.533 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.534 +
1.535 + // Read from position 0: start of file
1.536 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.537 +
1.538 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.539 + //from the file
1.540 +
1.541 + if (returnCode == KErrNotFound)
1.542 + {
1.543 + numSuccessful++;
1.544 + returnCode = ptrString.Find(KErrOOM);
1.545 + if (returnCode > 0)
1.546 + User::Leave(KErrNoMemory);
1.547 + }
1.548 +
1.549 +
1.550 + CleanupStack::PopAndDestroy(hBuffer);
1.551 + CleanupStack::PopAndDestroy(); //theFile
1.552 + CleanupStack::PopAndDestroy(); //fileSystem
1.553 +
1.554 + if (numSuccessful == 1)
1.555 + return KErrNone;
1.556 + else
1.557 + return KErrNotFound;
1.558 + }
1.559 +
1.560 +
1.561 +
1.562 +
1.563 +
1.564 +/**
1.565 +* 030_TagSetLogTag05: Test that flogger handles punctuation in tags
1.566 +*/
1.567 +
1.568 +CFloggerTest030_TagSetLogTag05::CFloggerTest030_TagSetLogTag05()
1.569 + {
1.570 + // Store the name of this test case
1.571 + SetTestStepName(_L("step_030_TagSetLogTag05"));
1.572 + }
1.573 +
1.574 +
1.575 +
1.576 +
1.577 +CFloggerTest030_TagSetLogTag05::~CFloggerTest030_TagSetLogTag05()
1.578 + {
1.579 + }
1.580 +
1.581 +
1.582 +
1.583 +
1.584 +TVerdict CFloggerTest030_TagSetLogTag05::doTestStepL( )
1.585 + {
1.586 + if ( executeStepL() == KErrNone )
1.587 + SetTestStepResult(EPass);
1.588 +
1.589 + else
1.590 + SetTestStepResult(EFail);
1.591 +
1.592 + User::After(KTimeForDisplay);
1.593 +
1.594 +
1.595 + return TestStepResult();
1.596 + }
1.597 +
1.598 +
1.599 +TInt CFloggerTest030_TagSetLogTag05::executeStepL(TBool)
1.600 + {
1.601 + return KErrGeneral;
1.602 + }
1.603 +
1.604 +TInt CFloggerTest030_TagSetLogTag05::executeStepL()
1.605 + {
1.606 +
1.607 + TInt ret ;
1.608 + RFileLogger theFlogger;
1.609 + ret = theFlogger.Connect();
1.610 +
1.611 + if ( ret == KErrNone)
1.612 + {
1.613 + //Create Log by passing the subsystem and component name as parameters
1.614 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.615 + theFlogger.ClearLog();
1.616 + theFlogger.SetLogTags(KSubsysTagWithPunctuationChars8, KCompTagWithPunctuationChars8);
1.617 + theFlogger.Write(KTestMessage);
1.618 + theFlogger.Close();
1.619 + User::After(KTimeToLog);
1.620 + TRAPD(r, ret = DoTestCheckWriteL());
1.621 + if (r != KErrNone)
1.622 + ret = r;
1.623 + }
1.624 +
1.625 + return ret;
1.626 +
1.627 + }
1.628 +
1.629 +
1.630 +
1.631 +
1.632 +TInt CFloggerTest030_TagSetLogTag05::DoTestCheckWriteL()
1.633 + {
1.634 + RFile theFile;
1.635 + HBufC8 * hBuffer;
1.636 + TInt listfilesize,returnCode;
1.637 + RFs fileSystem; //For file operation create a file system
1.638 + TUint numSuccessful = 0;
1.639 +
1.640 +
1.641 + User::LeaveIfError(fileSystem.Connect());
1.642 + CleanupClosePushL(fileSystem);
1.643 +
1.644 + //Open the file in the read mode
1.645 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.646 +
1.647 + CleanupClosePushL(theFile);
1.648 +
1.649 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.650 +
1.651 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.652 + CleanupStack::PushL(hBuffer);
1.653 +
1.654 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.655 +
1.656 + // Read from position 0: start of file
1.657 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.658 +
1.659 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.660 + //from the file
1.661 +
1.662 + if (returnCode == KErrNotFound)
1.663 + {
1.664 + numSuccessful++;
1.665 + returnCode = ptrString.Find(KErrOOM);
1.666 + if (returnCode > 0)
1.667 + User::Leave(KErrNoMemory);
1.668 + }
1.669 +
1.670 +
1.671 + CleanupStack::PopAndDestroy(hBuffer);
1.672 + CleanupStack::PopAndDestroy(); //theFile
1.673 + CleanupStack::PopAndDestroy(); //fileSystem
1.674 +
1.675 + if (numSuccessful == 1)
1.676 + return KErrNone;
1.677 + else
1.678 + return KErrNotFound;
1.679 + }
1.680 +
1.681 +
1.682 +/**
1.683 +* 030_TagSetLogTag06: Test that flogger handles long tags
1.684 +*/
1.685 +
1.686 +CFloggerTest030_TagSetLogTag06::CFloggerTest030_TagSetLogTag06()
1.687 + {
1.688 + // Store the name of this test case
1.689 + SetTestStepName(_L("step_030_TagSetLogTag06"));
1.690 + }
1.691 +
1.692 +
1.693 +
1.694 +
1.695 +CFloggerTest030_TagSetLogTag06::~CFloggerTest030_TagSetLogTag06()
1.696 + {
1.697 + }
1.698 +
1.699 +
1.700 +
1.701 +
1.702 +TVerdict CFloggerTest030_TagSetLogTag06::doTestStepL( )
1.703 + {
1.704 + if ( executeStepL() == KErrNone )
1.705 + SetTestStepResult(EPass);
1.706 +
1.707 + else
1.708 + SetTestStepResult(EFail);
1.709 +
1.710 + User::After(KTimeForDisplay);
1.711 +
1.712 +
1.713 + return TestStepResult();
1.714 + }
1.715 +
1.716 +
1.717 +TInt CFloggerTest030_TagSetLogTag06::executeStepL(TBool)
1.718 + {
1.719 + return KErrGeneral;
1.720 + }
1.721 +
1.722 +TInt CFloggerTest030_TagSetLogTag06::executeStepL()
1.723 + {
1.724 +
1.725 + TInt ret ;
1.726 + RFileLogger theFlogger;
1.727 + ret = theFlogger.Connect();
1.728 +
1.729 + if ( ret == KErrNone)
1.730 + {
1.731 + //Create Log by passing the subsystem and component name as parameters
1.732 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.733 + theFlogger.ClearLog();
1.734 + theFlogger.SetLogTags(KSubsysTag16char8, KCompTag16char8);
1.735 + theFlogger.Write(KTestMessage8);
1.736 + theFlogger.Close();
1.737 + User::After(KTimeToLog);
1.738 + TRAPD(r, ret = DoTestCheckWriteL());
1.739 + if (r != KErrNone)
1.740 + ret = r;
1.741 + }
1.742 +
1.743 + return ret;
1.744 +
1.745 + }
1.746 +
1.747 +
1.748 +
1.749 +
1.750 +TInt CFloggerTest030_TagSetLogTag06::DoTestCheckWriteL()
1.751 + {
1.752 + RFile theFile;
1.753 + HBufC8 * hBuffer;
1.754 + TInt listfilesize,returnCode;
1.755 + RFs fileSystem; //For file operation create a file system
1.756 + TUint numSuccessful = 0;
1.757 +
1.758 +
1.759 + User::LeaveIfError(fileSystem.Connect());
1.760 + CleanupClosePushL(fileSystem);
1.761 +
1.762 + //Open the file in the read mode
1.763 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.764 +
1.765 + CleanupClosePushL(theFile);
1.766 +
1.767 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.768 +
1.769 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.770 + CleanupStack::PushL(hBuffer);
1.771 +
1.772 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.773 +
1.774 + // Read from position 0: start of file
1.775 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.776 +
1.777 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.778 + //from the file
1.779 +
1.780 + if (returnCode > 0)
1.781 + {
1.782 + numSuccessful++;
1.783 + }
1.784 + else if (returnCode == KErrNotFound)
1.785 + {
1.786 + returnCode = ptrString.Find(KErrOOM);
1.787 + if (returnCode > 0)
1.788 + User::Leave(KErrNoMemory);
1.789 + }
1.790 +
1.791 +
1.792 + CleanupStack::PopAndDestroy(hBuffer);
1.793 + CleanupStack::PopAndDestroy(); //theFile
1.794 + CleanupStack::PopAndDestroy(); //fileSystem
1.795 +
1.796 + if (numSuccessful == 1)
1.797 + return KErrNone;
1.798 + else
1.799 + return KErrNotFound;
1.800 + }
1.801 +
1.802 +
1.803 +
1.804 +
1.805 +/**
1.806 +* 030_TagSetLogTag07: Test that flogger handles long tags
1.807 +*/
1.808 +
1.809 +CFloggerTest030_TagSetLogTag07::CFloggerTest030_TagSetLogTag07()
1.810 + {
1.811 + // Store the name of this test case
1.812 + SetTestStepName(_L("step_030_TagSetLogTag07"));
1.813 + }
1.814 +
1.815 +
1.816 +
1.817 +
1.818 +CFloggerTest030_TagSetLogTag07::~CFloggerTest030_TagSetLogTag07()
1.819 + {
1.820 + }
1.821 +
1.822 +
1.823 +
1.824 +
1.825 +TVerdict CFloggerTest030_TagSetLogTag07::doTestStepL( )
1.826 + {
1.827 + if ( executeStepL() == KErrNone )
1.828 + SetTestStepResult(EPass);
1.829 +
1.830 + else
1.831 + SetTestStepResult(EFail);
1.832 +
1.833 + User::After(KTimeForDisplay);
1.834 +
1.835 +
1.836 + return TestStepResult();
1.837 + }
1.838 +
1.839 +
1.840 +TInt CFloggerTest030_TagSetLogTag07::executeStepL(TBool)
1.841 + {
1.842 + return KErrGeneral;
1.843 + }
1.844 +
1.845 +TInt CFloggerTest030_TagSetLogTag07::executeStepL()
1.846 + {
1.847 +
1.848 + TInt ret ;
1.849 + RFileLogger theFlogger;
1.850 + ret = theFlogger.Connect();
1.851 +
1.852 + if ( ret == KErrNone)
1.853 + {
1.854 + //Create Log by passing the subsystem and component name as parameters
1.855 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.856 + theFlogger.ClearLog();
1.857 + theFlogger.SetLogTags(KSubsysTag17char8, KCompTag17char8);
1.858 + theFlogger.Write(KTestMessage8);
1.859 + theFlogger.Close();
1.860 + User::After(KTimeToLog);
1.861 + TRAPD(r, ret = DoTestCheckWriteL());
1.862 + if (r != KErrNone)
1.863 + ret = r;
1.864 + }
1.865 +
1.866 + return ret;
1.867 +
1.868 + }
1.869 +
1.870 +
1.871 +
1.872 +
1.873 +TInt CFloggerTest030_TagSetLogTag07::DoTestCheckWriteL()
1.874 + {
1.875 + RFile theFile;
1.876 + HBufC8 * hBuffer;
1.877 + TInt listfilesize,returnCode;
1.878 + RFs fileSystem; //For file operation create a file system
1.879 + TUint numSuccessful = 0;
1.880 +
1.881 +
1.882 + User::LeaveIfError(fileSystem.Connect());
1.883 + CleanupClosePushL(fileSystem);
1.884 +
1.885 + //Open the file in the read mode
1.886 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.887 +
1.888 + CleanupClosePushL(theFile);
1.889 +
1.890 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.891 +
1.892 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.893 + CleanupStack::PushL(hBuffer);
1.894 +
1.895 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.896 +
1.897 + // Read from position 0: start of file
1.898 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.899 +
1.900 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.901 + //from the file
1.902 +
1.903 + if (returnCode > 0)
1.904 + {
1.905 + numSuccessful++;
1.906 + }
1.907 + else if (returnCode == KErrNotFound)
1.908 + {
1.909 + returnCode = ptrString.Find(KErrOOM);
1.910 + if (returnCode > 0)
1.911 + User::Leave(KErrNoMemory);
1.912 + }
1.913 +
1.914 + // We expect to see the string "subsystem0123456" but not "subsystem01234567"
1.915 + returnCode = ptrString.Find(KSubsysTag16char8); //find the test descriptor in the buffer read
1.916 +
1.917 + if (returnCode > 0)
1.918 + {
1.919 + numSuccessful++;
1.920 + }
1.921 +
1.922 + returnCode = ptrString.Find(KSubsysTag17char8); //find the test descriptor in the buffer read
1.923 +
1.924 + if (returnCode == KErrNotFound)
1.925 + {
1.926 + numSuccessful++;
1.927 + }
1.928 +
1.929 + CleanupStack::PopAndDestroy(hBuffer);
1.930 + CleanupStack::PopAndDestroy(); //theFile
1.931 + CleanupStack::PopAndDestroy(); //fileSystem
1.932 +
1.933 + if (numSuccessful == 3)
1.934 + return KErrNone;
1.935 + else
1.936 + return KErrNotFound;
1.937 + }
1.938 +
1.939 +
1.940 +
1.941 +
1.942 +/**
1.943 +* 030_TagSetLogTag08: Test that flogger handles very long tags
1.944 +*/
1.945 +
1.946 +CFloggerTest030_TagSetLogTag08::CFloggerTest030_TagSetLogTag08()
1.947 + {
1.948 + // Store the name of this test case
1.949 + SetTestStepName(_L("step_030_TagSetLogTag08"));
1.950 + }
1.951 +
1.952 +
1.953 +
1.954 +
1.955 +CFloggerTest030_TagSetLogTag08::~CFloggerTest030_TagSetLogTag08()
1.956 + {
1.957 + }
1.958 +
1.959 +
1.960 +
1.961 +
1.962 +TVerdict CFloggerTest030_TagSetLogTag08::doTestStepL( )
1.963 + {
1.964 + if ( executeStepL() == KErrNone )
1.965 + SetTestStepResult(EPass);
1.966 +
1.967 + else
1.968 + SetTestStepResult(EFail);
1.969 +
1.970 + User::After(KTimeForDisplay);
1.971 +
1.972 +
1.973 + return TestStepResult();
1.974 + }
1.975 +
1.976 +
1.977 +TInt CFloggerTest030_TagSetLogTag08::executeStepL(TBool)
1.978 + {
1.979 + return KErrGeneral;
1.980 + }
1.981 +
1.982 +TInt CFloggerTest030_TagSetLogTag08::executeStepL()
1.983 + {
1.984 +
1.985 + TInt ret ;
1.986 + RFileLogger theFlogger;
1.987 + ret = theFlogger.Connect();
1.988 +
1.989 + if ( ret == KErrNone)
1.990 + {
1.991 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.992 + theFlogger.ClearLog();
1.993 + theFlogger.SetLogTags(KSubsysTag66char8, KCompTag66char8);
1.994 + theFlogger.Write(KTestMessage);
1.995 + theFlogger.Close();
1.996 + User::After(KTimeToLog);
1.997 + TRAPD(r, ret = DoTestCheckWriteL());
1.998 + if (r != KErrNone)
1.999 + ret = r;
1.1000 + }
1.1001 +
1.1002 + return ret;
1.1003 +
1.1004 + }
1.1005 +
1.1006 +
1.1007 +
1.1008 +
1.1009 +TInt CFloggerTest030_TagSetLogTag08::DoTestCheckWriteL()
1.1010 + {
1.1011 + RFile theFile;
1.1012 + HBufC8 * hBuffer;
1.1013 + TInt listfilesize,returnCode;
1.1014 + RFs fileSystem; //For file operation create a file system
1.1015 + TUint numSuccessful = 0;
1.1016 +
1.1017 +
1.1018 + User::LeaveIfError(fileSystem.Connect());
1.1019 + CleanupClosePushL(fileSystem);
1.1020 +
1.1021 + //Open the file in the read mode
1.1022 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.1023 +
1.1024 + CleanupClosePushL(theFile);
1.1025 +
1.1026 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.1027 +
1.1028 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.1029 + CleanupStack::PushL(hBuffer);
1.1030 +
1.1031 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.1032 +
1.1033 + // Read from position 0: start of file
1.1034 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.1035 +
1.1036 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.1037 + //from the file
1.1038 +
1.1039 + if (returnCode > 0)
1.1040 + {
1.1041 + numSuccessful++;
1.1042 + }
1.1043 + else if (returnCode == KErrNotFound)
1.1044 + {
1.1045 + returnCode = ptrString.Find(KErrOOM);
1.1046 + if (returnCode > 0)
1.1047 + User::Leave(KErrNoMemory);
1.1048 + }
1.1049 +
1.1050 + // We expect to see the string "subsystem0123456" but not "subsystem01234567"
1.1051 + returnCode = ptrString.Find(KSubsysTag16char8); //find the test descriptor in the buffer read
1.1052 +
1.1053 + if (returnCode > 0)
1.1054 + {
1.1055 + numSuccessful++;
1.1056 + }
1.1057 +
1.1058 + CleanupStack::PopAndDestroy(hBuffer);
1.1059 + CleanupStack::PopAndDestroy(); //theFile
1.1060 + CleanupStack::PopAndDestroy(); //fileSystem
1.1061 +
1.1062 + if (numSuccessful == 2)
1.1063 + return KErrNone;
1.1064 + else
1.1065 + return KErrNotFound;
1.1066 + }
1.1067 +
1.1068 +
1.1069 +
1.1070 +
1.1071 +/***************************************************************************************/
1.1072 +
1.1073 +/**
1.1074 +* 030_TagCreateLog01: Test that flogger handles empty tags
1.1075 +*/
1.1076 +
1.1077 +CFloggerTest030_TagCreateLog01::CFloggerTest030_TagCreateLog01()
1.1078 + {
1.1079 + // Store the name of this test case
1.1080 + SetTestStepName(_L("step_030_TagCreateLog01"));
1.1081 + }
1.1082 +
1.1083 +
1.1084 +
1.1085 +
1.1086 +CFloggerTest030_TagCreateLog01::~CFloggerTest030_TagCreateLog01()
1.1087 + {
1.1088 + }
1.1089 +
1.1090 +
1.1091 +
1.1092 +
1.1093 +TVerdict CFloggerTest030_TagCreateLog01::doTestStepL( )
1.1094 + {
1.1095 + if ( executeStepL() == KErrNone )
1.1096 + SetTestStepResult(EPass);
1.1097 +
1.1098 + else
1.1099 + SetTestStepResult(EFail);
1.1100 +
1.1101 + User::After(KTimeForDisplay);
1.1102 +
1.1103 +
1.1104 + return TestStepResult();
1.1105 + }
1.1106 +
1.1107 +
1.1108 +TInt CFloggerTest030_TagCreateLog01::executeStepL(TBool)
1.1109 + {
1.1110 + return KErrGeneral;
1.1111 + }
1.1112 +
1.1113 +TInt CFloggerTest030_TagCreateLog01::executeStepL()
1.1114 + {
1.1115 +
1.1116 + TInt ret ;
1.1117 + RFileLogger theFlogger;
1.1118 + ret = theFlogger.Connect();
1.1119 +
1.1120 + if ( ret == KErrNone)
1.1121 + {
1.1122 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.1123 + theFlogger.ClearLog();
1.1124 + theFlogger.CreateLog(KNullDesC16, KNullDesC16, EFileLoggingModeOverwrite);
1.1125 + theFlogger.Write(KTestMessage);
1.1126 + theFlogger.Close();
1.1127 + User::After(KTimeToLog);
1.1128 + TRAPD(r, ret = DoTestCheckWriteL());
1.1129 + if (r != KErrNone)
1.1130 + ret = r;
1.1131 + }
1.1132 +
1.1133 + return ret;
1.1134 +
1.1135 + }
1.1136 +
1.1137 +
1.1138 +
1.1139 +
1.1140 +TInt CFloggerTest030_TagCreateLog01::DoTestCheckWriteL()
1.1141 + {
1.1142 + RFile theFile;
1.1143 + HBufC8 * hBuffer;
1.1144 + TInt listfilesize,returnCode;
1.1145 + RFs fileSystem; //For file operation create a file system
1.1146 + TUint numSuccessful = 0;
1.1147 +
1.1148 +
1.1149 + User::LeaveIfError(fileSystem.Connect());
1.1150 + CleanupClosePushL(fileSystem);
1.1151 +
1.1152 + //Open the file in the read mode
1.1153 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.1154 +
1.1155 + CleanupClosePushL(theFile);
1.1156 +
1.1157 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.1158 +
1.1159 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.1160 + CleanupStack::PushL(hBuffer);
1.1161 +
1.1162 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.1163 +
1.1164 + // Read from position 0: start of file
1.1165 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.1166 +
1.1167 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.1168 + //from the file
1.1169 +
1.1170 + if (returnCode == KErrNotFound)
1.1171 + {
1.1172 + numSuccessful++;
1.1173 + returnCode = ptrString.Find(KErrOOM);
1.1174 + if (returnCode > 0)
1.1175 + User::Leave(KErrNoMemory);
1.1176 + }
1.1177 +
1.1178 +
1.1179 + CleanupStack::PopAndDestroy(hBuffer);
1.1180 + CleanupStack::PopAndDestroy(); //theFile
1.1181 + CleanupStack::PopAndDestroy(); //fileSystem
1.1182 +
1.1183 + if (numSuccessful == 1)
1.1184 + return KErrNone;
1.1185 + else
1.1186 + return KErrNotFound;
1.1187 + }
1.1188 +
1.1189 +
1.1190 +
1.1191 +
1.1192 +/**
1.1193 +* 030_TagCreateLog02: Test that flogger handles empty subsys tag
1.1194 +*/
1.1195 +
1.1196 +CFloggerTest030_TagCreateLog02::CFloggerTest030_TagCreateLog02()
1.1197 + {
1.1198 + // Store the name of this test case
1.1199 + SetTestStepName(_L("step_030_TagCreateLog02"));
1.1200 + }
1.1201 +
1.1202 +
1.1203 +
1.1204 +
1.1205 +CFloggerTest030_TagCreateLog02::~CFloggerTest030_TagCreateLog02()
1.1206 + {
1.1207 + }
1.1208 +
1.1209 +
1.1210 +
1.1211 +
1.1212 +TVerdict CFloggerTest030_TagCreateLog02::doTestStepL( )
1.1213 + {
1.1214 + if ( executeStepL() == KErrNone )
1.1215 + SetTestStepResult(EPass);
1.1216 +
1.1217 + else
1.1218 + SetTestStepResult(EFail);
1.1219 +
1.1220 + User::After(KTimeForDisplay);
1.1221 +
1.1222 +
1.1223 + return TestStepResult();
1.1224 + }
1.1225 +
1.1226 +TInt CFloggerTest030_TagCreateLog02::executeStepL(TBool)
1.1227 + {
1.1228 + return KErrGeneral;
1.1229 + }
1.1230 +
1.1231 +
1.1232 +TInt CFloggerTest030_TagCreateLog02::executeStepL()
1.1233 + {
1.1234 +
1.1235 + TInt ret ;
1.1236 + RFileLogger theFlogger;
1.1237 + ret = theFlogger.Connect();
1.1238 +
1.1239 + if ( ret == KErrNone)
1.1240 + {
1.1241 + //Create Log by passing the subsystem and component name as parameters
1.1242 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.1243 + theFlogger.ClearLog();
1.1244 + theFlogger.CreateLog(KNullDesC16, KStdCompTag16, EFileLoggingModeOverwrite);
1.1245 + theFlogger.Write(KTestMessage);
1.1246 + theFlogger.Close();
1.1247 + User::After(KTimeToLog);
1.1248 + TRAPD(r, ret = DoTestCheckWriteL());
1.1249 + if (r != KErrNone)
1.1250 + ret = r;
1.1251 + }
1.1252 +
1.1253 + return ret;
1.1254 +
1.1255 + }
1.1256 +
1.1257 +
1.1258 +
1.1259 +
1.1260 +TInt CFloggerTest030_TagCreateLog02::DoTestCheckWriteL()
1.1261 + {
1.1262 + RFile theFile;
1.1263 + HBufC8 * hBuffer;
1.1264 + TInt listfilesize,returnCode;
1.1265 + RFs fileSystem; //For file operation create a file system
1.1266 + TUint numSuccessful = 0;
1.1267 +
1.1268 +
1.1269 + User::LeaveIfError(fileSystem.Connect());
1.1270 + CleanupClosePushL(fileSystem);
1.1271 +
1.1272 + //Open the file in the read mode
1.1273 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.1274 +
1.1275 + CleanupClosePushL(theFile);
1.1276 +
1.1277 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.1278 +
1.1279 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.1280 + CleanupStack::PushL(hBuffer);
1.1281 +
1.1282 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.1283 +
1.1284 + // Read from position 0: start of file
1.1285 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.1286 +
1.1287 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.1288 + //from the file
1.1289 +
1.1290 + if (returnCode == KErrNotFound)
1.1291 + {
1.1292 + numSuccessful++;
1.1293 + returnCode = ptrString.Find(KErrOOM);
1.1294 + if (returnCode > 0)
1.1295 + User::Leave(KErrNoMemory);
1.1296 + }
1.1297 +
1.1298 +
1.1299 + CleanupStack::PopAndDestroy(hBuffer);
1.1300 + CleanupStack::PopAndDestroy(); //theFile
1.1301 + CleanupStack::PopAndDestroy(); //fileSystem
1.1302 +
1.1303 + if (numSuccessful == 1)
1.1304 + return KErrNone;
1.1305 + else
1.1306 + return KErrNotFound;
1.1307 + }
1.1308 +
1.1309 +
1.1310 +
1.1311 +/**
1.1312 +* 030_TagCreateLog03: Test that flogger handles empty component tag
1.1313 +*/
1.1314 +
1.1315 +CFloggerTest030_TagCreateLog03::CFloggerTest030_TagCreateLog03()
1.1316 + {
1.1317 + // Store the name of this test case
1.1318 + SetTestStepName(_L("step_030_TagCreateLog03"));
1.1319 + }
1.1320 +
1.1321 +
1.1322 +
1.1323 +
1.1324 +CFloggerTest030_TagCreateLog03::~CFloggerTest030_TagCreateLog03()
1.1325 + {
1.1326 + }
1.1327 +
1.1328 +
1.1329 +
1.1330 +
1.1331 +TVerdict CFloggerTest030_TagCreateLog03::doTestStepL( )
1.1332 + {
1.1333 + if ( executeStepL() == KErrNone )
1.1334 + SetTestStepResult(EPass);
1.1335 +
1.1336 + else
1.1337 + SetTestStepResult(EFail);
1.1338 +
1.1339 + User::After(KTimeForDisplay);
1.1340 +
1.1341 +
1.1342 + return TestStepResult();
1.1343 + }
1.1344 +
1.1345 +
1.1346 +TInt CFloggerTest030_TagCreateLog03::executeStepL(TBool)
1.1347 + {
1.1348 + return KErrGeneral;
1.1349 + }
1.1350 +
1.1351 +TInt CFloggerTest030_TagCreateLog03::executeStepL()
1.1352 + {
1.1353 +
1.1354 + TInt ret ;
1.1355 + RFileLogger theFlogger;
1.1356 + ret = theFlogger.Connect();
1.1357 +
1.1358 + if ( ret == KErrNone)
1.1359 + {
1.1360 + //Create Log by passing the subsystem and component name as parameters
1.1361 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.1362 + theFlogger.ClearLog();
1.1363 + theFlogger.CreateLog(KStdSubsysTag16, KNullDesC16, EFileLoggingModeOverwrite);
1.1364 + theFlogger.Write(KTestMessage);
1.1365 + theFlogger.Close();
1.1366 + User::After(KTimeToLog);
1.1367 + TRAPD(r, ret = DoTestCheckWriteL());
1.1368 + if (r != KErrNone)
1.1369 + ret = r;
1.1370 + }
1.1371 +
1.1372 + return ret;
1.1373 +
1.1374 + }
1.1375 +
1.1376 +
1.1377 +
1.1378 +
1.1379 +TInt CFloggerTest030_TagCreateLog03::DoTestCheckWriteL()
1.1380 + {
1.1381 + RFile theFile;
1.1382 + HBufC8 * hBuffer;
1.1383 + TInt listfilesize,returnCode;
1.1384 + RFs fileSystem; //For file operation create a file system
1.1385 + TUint numSuccessful = 0;
1.1386 +
1.1387 +
1.1388 + User::LeaveIfError(fileSystem.Connect());
1.1389 + CleanupClosePushL(fileSystem);
1.1390 +
1.1391 + //Open the file in the read mode
1.1392 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.1393 +
1.1394 + CleanupClosePushL(theFile);
1.1395 +
1.1396 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.1397 +
1.1398 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.1399 + CleanupStack::PushL(hBuffer);
1.1400 +
1.1401 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.1402 +
1.1403 + // Read from position 0: start of file
1.1404 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.1405 +
1.1406 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.1407 + //from the file
1.1408 +
1.1409 + if (returnCode == KErrNotFound)
1.1410 + {
1.1411 + numSuccessful++;
1.1412 + returnCode = ptrString.Find(KErrOOM);
1.1413 + if (returnCode > 0)
1.1414 + User::Leave(KErrNoMemory);
1.1415 + }
1.1416 +
1.1417 +
1.1418 + CleanupStack::PopAndDestroy(hBuffer);
1.1419 + CleanupStack::PopAndDestroy(); //theFile
1.1420 + CleanupStack::PopAndDestroy(); //fileSystem
1.1421 +
1.1422 + if (numSuccessful == 1)
1.1423 + return KErrNone;
1.1424 + else
1.1425 + return KErrNotFound;
1.1426 + }
1.1427 +
1.1428 +
1.1429 +
1.1430 +
1.1431 +/**
1.1432 +* 030_TagCreateLog04: Test that flogger handles spaces in tags
1.1433 +*/
1.1434 +
1.1435 +CFloggerTest030_TagCreateLog04::CFloggerTest030_TagCreateLog04()
1.1436 + {
1.1437 + // Store the name of this test case
1.1438 + SetTestStepName(_L("step_030_TagCreateLog04"));
1.1439 + }
1.1440 +
1.1441 +
1.1442 +
1.1443 +
1.1444 +CFloggerTest030_TagCreateLog04::~CFloggerTest030_TagCreateLog04()
1.1445 + {
1.1446 + }
1.1447 +
1.1448 +
1.1449 +
1.1450 +
1.1451 +TVerdict CFloggerTest030_TagCreateLog04::doTestStepL( )
1.1452 + {
1.1453 + if ( executeStepL() == KErrNone )
1.1454 + SetTestStepResult(EPass);
1.1455 +
1.1456 + else
1.1457 + SetTestStepResult(EFail);
1.1458 +
1.1459 + User::After(KTimeForDisplay);
1.1460 +
1.1461 +
1.1462 + return TestStepResult();
1.1463 + }
1.1464 +
1.1465 +
1.1466 +TInt CFloggerTest030_TagCreateLog04::executeStepL(TBool)
1.1467 + {
1.1468 + return KErrGeneral;
1.1469 + }
1.1470 +
1.1471 +TInt CFloggerTest030_TagCreateLog04::executeStepL()
1.1472 + {
1.1473 +
1.1474 + TInt ret ;
1.1475 + RFileLogger theFlogger;
1.1476 + ret = theFlogger.Connect();
1.1477 +
1.1478 + if ( ret == KErrNone)
1.1479 + {
1.1480 + //Create Log by passing the subsystem and component name as parameters
1.1481 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.1482 + theFlogger.ClearLog();
1.1483 + theFlogger.CreateLog(KStdSubsysTag16, KCompTagWithSpaceChars16, EFileLoggingModeOverwrite);
1.1484 + theFlogger.Write(KTestMessage);
1.1485 + theFlogger.Close();
1.1486 + User::After(KTimeToLog);
1.1487 + TRAPD(r, ret = DoTestCheckWriteL());
1.1488 + if (r != KErrNone)
1.1489 + ret = r;
1.1490 + }
1.1491 +
1.1492 + return ret;
1.1493 +
1.1494 + }
1.1495 +
1.1496 +
1.1497 +
1.1498 +
1.1499 +TInt CFloggerTest030_TagCreateLog04::DoTestCheckWriteL()
1.1500 + {
1.1501 + RFile theFile;
1.1502 + HBufC8 * hBuffer;
1.1503 + TInt listfilesize,returnCode;
1.1504 + RFs fileSystem; //For file operation create a file system
1.1505 + TUint numSuccessful = 0;
1.1506 +
1.1507 +
1.1508 + User::LeaveIfError(fileSystem.Connect());
1.1509 + CleanupClosePushL(fileSystem);
1.1510 +
1.1511 + //Open the file in the read mode
1.1512 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.1513 +
1.1514 + CleanupClosePushL(theFile);
1.1515 +
1.1516 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.1517 +
1.1518 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.1519 + CleanupStack::PushL(hBuffer);
1.1520 +
1.1521 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.1522 +
1.1523 + // Read from position 0: start of file
1.1524 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.1525 +
1.1526 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.1527 + //from the file
1.1528 +
1.1529 + if (returnCode == KErrNotFound)
1.1530 + {
1.1531 + numSuccessful++;
1.1532 + returnCode = ptrString.Find(KErrOOM);
1.1533 + if (returnCode > 0)
1.1534 + User::Leave(KErrNoMemory);
1.1535 + }
1.1536 +
1.1537 +
1.1538 + CleanupStack::PopAndDestroy(hBuffer);
1.1539 + CleanupStack::PopAndDestroy(); //theFile
1.1540 + CleanupStack::PopAndDestroy(); //fileSystem
1.1541 +
1.1542 + if (numSuccessful == 1)
1.1543 + return KErrNone;
1.1544 + else
1.1545 + return KErrNotFound;
1.1546 + }
1.1547 +
1.1548 +
1.1549 +
1.1550 +
1.1551 +
1.1552 +/**
1.1553 +* 030_TagCreateLog05: Test that flogger handles punctuation in tags
1.1554 +*/
1.1555 +
1.1556 +CFloggerTest030_TagCreateLog05::CFloggerTest030_TagCreateLog05()
1.1557 + {
1.1558 + // Store the name of this test case
1.1559 + SetTestStepName(_L("step_030_TagCreateLog05"));
1.1560 + }
1.1561 +
1.1562 +
1.1563 +
1.1564 +
1.1565 +CFloggerTest030_TagCreateLog05::~CFloggerTest030_TagCreateLog05()
1.1566 + {
1.1567 + }
1.1568 +
1.1569 +
1.1570 +
1.1571 +
1.1572 +TVerdict CFloggerTest030_TagCreateLog05::doTestStepL( )
1.1573 + {
1.1574 + if ( executeStepL() == KErrNone )
1.1575 + SetTestStepResult(EPass);
1.1576 +
1.1577 + else
1.1578 + SetTestStepResult(EFail);
1.1579 +
1.1580 + User::After(KTimeForDisplay);
1.1581 +
1.1582 +
1.1583 + return TestStepResult();
1.1584 + }
1.1585 +
1.1586 +
1.1587 +TInt CFloggerTest030_TagCreateLog05::executeStepL(TBool)
1.1588 +{
1.1589 +return KErrGeneral;
1.1590 +}
1.1591 +
1.1592 +TInt CFloggerTest030_TagCreateLog05::executeStepL()
1.1593 + {
1.1594 +
1.1595 + TInt ret ;
1.1596 + RFileLogger theFlogger;
1.1597 + ret = theFlogger.Connect();
1.1598 +
1.1599 + if ( ret == KErrNone)
1.1600 + {
1.1601 + //Create Log by passing the subsystem and component name as parameters
1.1602 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.1603 + theFlogger.ClearLog();
1.1604 + theFlogger.CreateLog(KSubsysTagWithPunctuationChars16, KCompTagWithPunctuationChars16, EFileLoggingModeOverwrite);
1.1605 + theFlogger.Write(KTestMessage);
1.1606 + theFlogger.Close();
1.1607 + User::After(KTimeToLog);
1.1608 + TRAPD(r, ret = DoTestCheckWriteL());
1.1609 + if (r != KErrNone)
1.1610 + ret = r;
1.1611 + }
1.1612 +
1.1613 + return ret;
1.1614 +
1.1615 + }
1.1616 +
1.1617 +
1.1618 +
1.1619 +
1.1620 +TInt CFloggerTest030_TagCreateLog05::DoTestCheckWriteL()
1.1621 + {
1.1622 + RFile theFile;
1.1623 + HBufC8 * hBuffer;
1.1624 + TInt listfilesize,returnCode;
1.1625 + RFs fileSystem; //For file operation create a file system
1.1626 + TUint numSuccessful = 0;
1.1627 +
1.1628 +
1.1629 + User::LeaveIfError(fileSystem.Connect());
1.1630 + CleanupClosePushL(fileSystem);
1.1631 +
1.1632 + //Open the file in the read mode
1.1633 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.1634 +
1.1635 + CleanupClosePushL(theFile);
1.1636 +
1.1637 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.1638 +
1.1639 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.1640 + CleanupStack::PushL(hBuffer);
1.1641 +
1.1642 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.1643 +
1.1644 + // Read from position 0: start of file
1.1645 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.1646 +
1.1647 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.1648 + //from the file
1.1649 +
1.1650 + if (returnCode == KErrNotFound)
1.1651 + {
1.1652 + numSuccessful++;
1.1653 + returnCode = ptrString.Find(KErrOOM);
1.1654 + if (returnCode > 0)
1.1655 + User::Leave(KErrNoMemory);
1.1656 + }
1.1657 +
1.1658 +
1.1659 + CleanupStack::PopAndDestroy(hBuffer);
1.1660 + CleanupStack::PopAndDestroy(); //theFile
1.1661 + CleanupStack::PopAndDestroy(); //fileSystem
1.1662 +
1.1663 + if (numSuccessful == 1)
1.1664 + return KErrNone;
1.1665 + else
1.1666 + return KErrNotFound;
1.1667 + }
1.1668 +
1.1669 +
1.1670 +
1.1671 +/**
1.1672 +* 030_TagCreateLog06: Test that flogger handles length 16 tags
1.1673 +*/
1.1674 +
1.1675 +CFloggerTest030_TagCreateLog06::CFloggerTest030_TagCreateLog06()
1.1676 + {
1.1677 + // Store the name of this test case
1.1678 + SetTestStepName(_L("step_030_TagCreateLog06"));
1.1679 + }
1.1680 +
1.1681 +
1.1682 +
1.1683 +
1.1684 +CFloggerTest030_TagCreateLog06::~CFloggerTest030_TagCreateLog06()
1.1685 + {
1.1686 + }
1.1687 +
1.1688 +
1.1689 +
1.1690 +
1.1691 +TVerdict CFloggerTest030_TagCreateLog06::doTestStepL( )
1.1692 + {
1.1693 + if ( executeStepL() == KErrNone )
1.1694 + SetTestStepResult(EPass);
1.1695 +
1.1696 + else
1.1697 + SetTestStepResult(EFail);
1.1698 +
1.1699 + User::After(KTimeForDisplay);
1.1700 +
1.1701 +
1.1702 + return TestStepResult();
1.1703 + }
1.1704 +
1.1705 +
1.1706 +TInt CFloggerTest030_TagCreateLog06::executeStepL(TBool)
1.1707 + {
1.1708 + return KErrGeneral;
1.1709 + }
1.1710 +
1.1711 +TInt CFloggerTest030_TagCreateLog06::executeStepL()
1.1712 + {
1.1713 +
1.1714 + TInt ret ;
1.1715 + RFileLogger theFlogger;
1.1716 + ret = theFlogger.Connect();
1.1717 +
1.1718 + if ( ret == KErrNone)
1.1719 + {
1.1720 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.1721 + theFlogger.ClearLog();
1.1722 + theFlogger.CreateLog(KSubsysTag16char16, KCompTag16char16, EFileLoggingModeOverwrite);
1.1723 + theFlogger.Write(KTestMessage);
1.1724 + theFlogger.Close();
1.1725 + User::After(KTimeToLog);
1.1726 + TRAPD(r, ret = DoTestCheckWriteL());
1.1727 + if (r != KErrNone)
1.1728 + ret = r;
1.1729 + }
1.1730 +
1.1731 + return ret;
1.1732 +
1.1733 + }
1.1734 +
1.1735 +
1.1736 +
1.1737 +
1.1738 +
1.1739 +TInt CFloggerTest030_TagCreateLog06::DoTestCheckWriteL()
1.1740 + {
1.1741 + RFile theFile;
1.1742 + HBufC8 * hBuffer;
1.1743 + TInt listfilesize,returnCode;
1.1744 + RFs fileSystem; //For file operation create a file system
1.1745 + TBuf8<256> testData; //To hold the test descriptor
1.1746 +
1.1747 +
1.1748 + _LIT8(KOOMError, "#Logs may be lost out of memory!!");
1.1749 +
1.1750 + User::LeaveIfError(fileSystem.Connect());
1.1751 +
1.1752 + //Open the file in the read mode
1.1753 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.1754 +
1.1755 + CleanupClosePushL(theFile);
1.1756 +
1.1757 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.1758 +
1.1759 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.1760 + CleanupStack::PushL(hBuffer);
1.1761 +
1.1762 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.1763 +
1.1764 + // Read from position 0: start of file
1.1765 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.1766 +
1.1767 + testData.Copy(KTestMessage); //Copy the test descriptor
1.1768 + returnCode = ptrString.Find(testData); //find the test descriptor in the buffer read
1.1769 + //from the file
1.1770 +
1.1771 + if (returnCode == KErrNotFound)
1.1772 + {
1.1773 + returnCode = ptrString.Find(KOOMError);
1.1774 + if (returnCode > 0)
1.1775 + User::Leave(KErrNoMemory);
1.1776 + }
1.1777 +
1.1778 +
1.1779 + CleanupStack::PopAndDestroy(hBuffer);
1.1780 + CleanupStack::PopAndDestroy(); //theFile
1.1781 + if (returnCode > 0)
1.1782 + return KErrNone;
1.1783 + else
1.1784 + return KErrNotFound;
1.1785 + }
1.1786 +
1.1787 +
1.1788 +
1.1789 +
1.1790 +
1.1791 +
1.1792 +
1.1793 +
1.1794 +/**
1.1795 +* 030_TagCreateLog07: Test that flogger handles length 17 tags by truncating
1.1796 +*/
1.1797 +
1.1798 +CFloggerTest030_TagCreateLog07::CFloggerTest030_TagCreateLog07()
1.1799 + {
1.1800 + // Store the name of this test case
1.1801 + SetTestStepName(_L("step_030_TagCreateLog07"));
1.1802 + }
1.1803 +
1.1804 +
1.1805 +
1.1806 +
1.1807 +CFloggerTest030_TagCreateLog07::~CFloggerTest030_TagCreateLog07()
1.1808 + {
1.1809 + }
1.1810 +
1.1811 +
1.1812 +
1.1813 +
1.1814 +TVerdict CFloggerTest030_TagCreateLog07::doTestStepL( )
1.1815 + {
1.1816 + if ( executeStepL() == KErrNone )
1.1817 + SetTestStepResult(EPass);
1.1818 +
1.1819 + else
1.1820 + SetTestStepResult(EFail);
1.1821 +
1.1822 + User::After(KTimeForDisplay);
1.1823 +
1.1824 +
1.1825 + return TestStepResult();
1.1826 + }
1.1827 +
1.1828 +
1.1829 +TInt CFloggerTest030_TagCreateLog07::executeStepL(TBool)
1.1830 + {
1.1831 + return KErrGeneral;
1.1832 + }
1.1833 +
1.1834 +TInt CFloggerTest030_TagCreateLog07::executeStepL()
1.1835 + {
1.1836 +
1.1837 + TInt ret ;
1.1838 + RFileLogger theFlogger;
1.1839 + ret = theFlogger.Connect();
1.1840 +
1.1841 + if ( ret == KErrNone)
1.1842 + {
1.1843 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.1844 + theFlogger.ClearLog();
1.1845 + theFlogger.CreateLog(KSubsysTag17char16, KCompTag17char16, EFileLoggingModeOverwrite);
1.1846 + theFlogger.Write(KTestMessage);
1.1847 + theFlogger.Close();
1.1848 + User::After(KTimeToLog);
1.1849 + TRAPD(r, ret = DoTestCheckWriteL());
1.1850 + if (r != KErrNone)
1.1851 + ret = r;
1.1852 + }
1.1853 +
1.1854 + return ret;
1.1855 +
1.1856 + }
1.1857 +
1.1858 +
1.1859 +
1.1860 +/**
1.1861 +* This function checks whether test data was written
1.1862 +* in to the log file .
1.1863 +*/
1.1864 +
1.1865 +
1.1866 +TInt CFloggerTest030_TagCreateLog07::DoTestCheckWriteL()
1.1867 + {
1.1868 + RFile theFile;
1.1869 + HBufC8 * hBuffer;
1.1870 + TInt listfilesize,returnCode;
1.1871 + RFs fileSystem; //For file operation create a file system
1.1872 + TBuf8<256> testData; //To hold the test descriptor
1.1873 + TInt numSuccessful = 0;
1.1874 +
1.1875 +
1.1876 + _LIT8(KOOMError, "#Logs may be lost out of memory!!");
1.1877 +
1.1878 + User::LeaveIfError(fileSystem.Connect());
1.1879 +
1.1880 + //Open the file in the read mode
1.1881 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.1882 +
1.1883 + CleanupClosePushL(theFile);
1.1884 +
1.1885 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.1886 +
1.1887 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.1888 + CleanupStack::PushL(hBuffer);
1.1889 +
1.1890 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.1891 +
1.1892 + // Read from position 0: start of file
1.1893 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.1894 +
1.1895 + testData.Copy(KTestMessage); //Copy the test descriptor
1.1896 + returnCode = ptrString.Find(testData); //find the test descriptor in the buffer read
1.1897 + //from the file
1.1898 + if (returnCode > 0)
1.1899 + {
1.1900 + numSuccessful++;
1.1901 + }
1.1902 +
1.1903 + // We expect to see the string "subsystem0123456" but not "subsystem01234567"
1.1904 + testData.Copy(KSubsysTag16char16); //Copy the test descriptor
1.1905 + returnCode = ptrString.Find(testData); //find the test descriptor in the buffer read
1.1906 +
1.1907 + if (returnCode > 0)
1.1908 + {
1.1909 + numSuccessful++;
1.1910 + }
1.1911 +
1.1912 + testData.Copy(KSubsysTag17char16); //Copy the test descriptor
1.1913 + returnCode = ptrString.Find(testData); //find the test descriptor in the buffer read
1.1914 +
1.1915 + if (returnCode == KErrNotFound)
1.1916 + {
1.1917 + numSuccessful++;
1.1918 + }
1.1919 +
1.1920 + if (returnCode == KErrNotFound)
1.1921 + {
1.1922 + returnCode = ptrString.Find(KOOMError);
1.1923 + if (returnCode > 0)
1.1924 + User::Leave(KErrNoMemory);
1.1925 + }
1.1926 +
1.1927 +
1.1928 +
1.1929 + CleanupStack::PopAndDestroy(hBuffer);
1.1930 + CleanupStack::PopAndDestroy(); //theFile
1.1931 + if (numSuccessful == 3)
1.1932 + return KErrNone;
1.1933 + else
1.1934 + return KErrNotFound;
1.1935 + }
1.1936 +
1.1937 +
1.1938 +/**
1.1939 +* 030_TagCreateLog08: Test that flogger handles very long tags
1.1940 +*/
1.1941 +
1.1942 +CFloggerTest030_TagCreateLog08::CFloggerTest030_TagCreateLog08()
1.1943 + {
1.1944 + // Store the name of this test case
1.1945 + SetTestStepName(_L("step_030_TagCreateLog08"));
1.1946 + }
1.1947 +
1.1948 +
1.1949 +
1.1950 +
1.1951 +CFloggerTest030_TagCreateLog08::~CFloggerTest030_TagCreateLog08()
1.1952 + {
1.1953 + }
1.1954 +
1.1955 +
1.1956 +
1.1957 +
1.1958 +TVerdict CFloggerTest030_TagCreateLog08::doTestStepL( )
1.1959 + {
1.1960 + if ( executeStepL() == KErrNone )
1.1961 + SetTestStepResult(EPass);
1.1962 +
1.1963 + else
1.1964 + SetTestStepResult(EFail);
1.1965 +
1.1966 + User::After(KTimeForDisplay);
1.1967 +
1.1968 +
1.1969 + return TestStepResult();
1.1970 + }
1.1971 +
1.1972 +
1.1973 +TInt CFloggerTest030_TagCreateLog08::executeStepL(TBool)
1.1974 + {
1.1975 + return KErrGeneral;
1.1976 + }
1.1977 +
1.1978 +TInt CFloggerTest030_TagCreateLog08::executeStepL()
1.1979 + {
1.1980 +
1.1981 + TInt ret ;
1.1982 + RFileLogger theFlogger;
1.1983 + ret = theFlogger.Connect();
1.1984 +
1.1985 + if ( ret == KErrNone)
1.1986 + {
1.1987 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.1988 + theFlogger.ClearLog();
1.1989 + theFlogger.CreateLog(KSubsysTag66char16, KCompTag66char16, EFileLoggingModeOverwrite);
1.1990 + theFlogger.Write(KTestMessage);
1.1991 + theFlogger.Close();
1.1992 + User::After(KTimeToLog);
1.1993 + TRAPD(r, ret = DoTestCheckWriteL());
1.1994 + if (r != KErrNone)
1.1995 + ret = r;
1.1996 + }
1.1997 +
1.1998 + return ret;
1.1999 +
1.2000 + }
1.2001 +
1.2002 +
1.2003 +
1.2004 +
1.2005 +TInt CFloggerTest030_TagCreateLog08::DoTestCheckWriteL()
1.2006 + {
1.2007 + RFile theFile;
1.2008 + HBufC8 * hBuffer;
1.2009 + TInt listfilesize,returnCode;
1.2010 + RFs fileSystem; //For file operation create a file system
1.2011 + TUint numSuccessful = 0;
1.2012 +
1.2013 +
1.2014 + User::LeaveIfError(fileSystem.Connect());
1.2015 + CleanupClosePushL(fileSystem);
1.2016 +
1.2017 + //Open the file in the read mode
1.2018 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.2019 +
1.2020 + CleanupClosePushL(theFile);
1.2021 +
1.2022 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.2023 +
1.2024 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.2025 + CleanupStack::PushL(hBuffer);
1.2026 +
1.2027 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.2028 +
1.2029 + // Read from position 0: start of file
1.2030 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.2031 +
1.2032 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.2033 + //from the file
1.2034 +
1.2035 + if (returnCode > 0)
1.2036 + {
1.2037 + numSuccessful++;
1.2038 + }
1.2039 + else if (returnCode == KErrNotFound)
1.2040 + {
1.2041 + returnCode = ptrString.Find(KErrOOM);
1.2042 + if (returnCode > 0)
1.2043 + User::Leave(KErrNoMemory);
1.2044 + }
1.2045 +
1.2046 + // We expect to see the string "subsystem0123456" but not "subsystem01234567"
1.2047 + returnCode = ptrString.Find(KSubsysTag16char8); //find the test descriptor in the buffer read
1.2048 +
1.2049 + if (returnCode > 0)
1.2050 + {
1.2051 + numSuccessful++;
1.2052 + }
1.2053 +
1.2054 + CleanupStack::PopAndDestroy(hBuffer);
1.2055 + CleanupStack::PopAndDestroy(); //theFile
1.2056 + CleanupStack::PopAndDestroy(); //fileSystem
1.2057 +
1.2058 + if (numSuccessful == 2)
1.2059 + return KErrNone;
1.2060 + else
1.2061 + return KErrNotFound;
1.2062 + }
1.2063 +
1.2064 +
1.2065 +
1.2066 +
1.2067 +/***************************************************************************************/
1.2068 +
1.2069 +
1.2070 +/**
1.2071 +* 030_TagWrite01: Test that flogger handles empty tags
1.2072 +*/
1.2073 +
1.2074 +CFloggerTest030_TagWrite01::CFloggerTest030_TagWrite01()
1.2075 + {
1.2076 + // Store the name of this test case
1.2077 + SetTestStepName(_L("step_030_TagWrite01"));
1.2078 + }
1.2079 +
1.2080 +
1.2081 +
1.2082 +
1.2083 +CFloggerTest030_TagWrite01::~CFloggerTest030_TagWrite01()
1.2084 + {
1.2085 + }
1.2086 +
1.2087 +
1.2088 +
1.2089 +
1.2090 +TVerdict CFloggerTest030_TagWrite01::doTestStepL( )
1.2091 + {
1.2092 + if ( executeStepL() == KErrNone )
1.2093 + SetTestStepResult(EPass);
1.2094 +
1.2095 + else
1.2096 + SetTestStepResult(EFail);
1.2097 +
1.2098 + User::After(KTimeForDisplay);
1.2099 +
1.2100 +
1.2101 + return TestStepResult();
1.2102 + }
1.2103 +
1.2104 +
1.2105 +TInt CFloggerTest030_TagWrite01::executeStepL(TBool)
1.2106 + {
1.2107 + return KErrGeneral;
1.2108 + }
1.2109 +
1.2110 +TInt CFloggerTest030_TagWrite01::executeStepL()
1.2111 + {
1.2112 +
1.2113 + TInt ret ;
1.2114 + RFileLogger theFlogger;
1.2115 + ret = theFlogger.Connect();
1.2116 +
1.2117 + if ( ret == KErrNone)
1.2118 + {
1.2119 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.2120 + theFlogger.ClearLog();
1.2121 + theFlogger.Close();
1.2122 + RFileLogger::Write(KNullDesC8, KNullDesC8,KTestMessage);
1.2123 + User::After(KTimeToLog);
1.2124 + TRAPD(r, ret = DoTestCheckWriteL());
1.2125 + if (r != KErrNone)
1.2126 + ret = r;
1.2127 + }
1.2128 +
1.2129 + return ret;
1.2130 +
1.2131 + }
1.2132 +
1.2133 +
1.2134 +
1.2135 +
1.2136 +TInt CFloggerTest030_TagWrite01::DoTestCheckWriteL()
1.2137 + {
1.2138 + RFile theFile;
1.2139 + HBufC8 * hBuffer;
1.2140 + TInt listfilesize,returnCode;
1.2141 + RFs fileSystem; //For file operation create a file system
1.2142 + TUint numSuccessful = 0;
1.2143 +
1.2144 +
1.2145 + User::LeaveIfError(fileSystem.Connect());
1.2146 + CleanupClosePushL(fileSystem);
1.2147 +
1.2148 + //Open the file in the read mode
1.2149 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.2150 +
1.2151 + CleanupClosePushL(theFile);
1.2152 +
1.2153 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.2154 +
1.2155 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.2156 + CleanupStack::PushL(hBuffer);
1.2157 +
1.2158 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.2159 +
1.2160 + // Read from position 0: start of file
1.2161 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.2162 +
1.2163 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.2164 + //from the file
1.2165 +
1.2166 + if (returnCode == KErrNotFound)
1.2167 + {
1.2168 + numSuccessful++;
1.2169 + returnCode = ptrString.Find(KErrOOM);
1.2170 + if (returnCode > 0)
1.2171 + User::Leave(KErrNoMemory);
1.2172 + }
1.2173 +
1.2174 +
1.2175 + CleanupStack::PopAndDestroy(hBuffer);
1.2176 + CleanupStack::PopAndDestroy(); //theFile
1.2177 + CleanupStack::PopAndDestroy(); //fileSystem
1.2178 +
1.2179 + if (numSuccessful == 1)
1.2180 + return KErrNone;
1.2181 + else
1.2182 + return KErrNotFound;
1.2183 + }
1.2184 +
1.2185 +
1.2186 +
1.2187 +
1.2188 +/**
1.2189 +* 030_TagWrite02: Test that flogger handles empty subsys tag
1.2190 +*/
1.2191 +
1.2192 +CFloggerTest030_TagWrite02::CFloggerTest030_TagWrite02()
1.2193 + {
1.2194 + // Store the name of this test case
1.2195 + SetTestStepName(_L("step_030_TagWrite02"));
1.2196 + }
1.2197 +
1.2198 +
1.2199 +
1.2200 +
1.2201 +CFloggerTest030_TagWrite02::~CFloggerTest030_TagWrite02()
1.2202 + {
1.2203 + }
1.2204 +
1.2205 +
1.2206 +
1.2207 +
1.2208 +TVerdict CFloggerTest030_TagWrite02::doTestStepL( )
1.2209 + {
1.2210 + if ( executeStepL() == KErrNone )
1.2211 + SetTestStepResult(EPass);
1.2212 +
1.2213 + else
1.2214 + SetTestStepResult(EFail);
1.2215 +
1.2216 + User::After(KTimeForDisplay);
1.2217 +
1.2218 +
1.2219 + return TestStepResult();
1.2220 + }
1.2221 +
1.2222 +
1.2223 +TInt CFloggerTest030_TagWrite02::executeStepL(TBool)
1.2224 + {
1.2225 + return KErrGeneral;
1.2226 + }
1.2227 +
1.2228 +TInt CFloggerTest030_TagWrite02::executeStepL()
1.2229 + {
1.2230 +
1.2231 + TInt ret ;
1.2232 + RFileLogger theFlogger;
1.2233 + ret = theFlogger.Connect();
1.2234 +
1.2235 + if ( ret == KErrNone)
1.2236 + {
1.2237 + //Create Log by passing the subsystem and component name as parameters
1.2238 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.2239 + theFlogger.ClearLog();
1.2240 + theFlogger.Close();
1.2241 + RFileLogger::Write(KNullDesC8, KStdCompTag8,KTestMessage);
1.2242 + User::After(KTimeToLog);
1.2243 + TRAPD(r, ret = DoTestCheckWriteL());
1.2244 + if (r != KErrNone)
1.2245 + ret = r;
1.2246 + }
1.2247 +
1.2248 + return ret;
1.2249 +
1.2250 + }
1.2251 +
1.2252 +
1.2253 +
1.2254 +
1.2255 +TInt CFloggerTest030_TagWrite02::DoTestCheckWriteL()
1.2256 + {
1.2257 + RFile theFile;
1.2258 + HBufC8 * hBuffer;
1.2259 + TInt listfilesize,returnCode;
1.2260 + RFs fileSystem; //For file operation create a file system
1.2261 + TUint numSuccessful = 0;
1.2262 +
1.2263 +
1.2264 + User::LeaveIfError(fileSystem.Connect());
1.2265 + CleanupClosePushL(fileSystem);
1.2266 +
1.2267 + //Open the file in the read mode
1.2268 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.2269 +
1.2270 + CleanupClosePushL(theFile);
1.2271 +
1.2272 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.2273 +
1.2274 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.2275 + CleanupStack::PushL(hBuffer);
1.2276 +
1.2277 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.2278 +
1.2279 + // Read from position 0: start of file
1.2280 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.2281 +
1.2282 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.2283 + //from the file
1.2284 +
1.2285 + if (returnCode == KErrNotFound)
1.2286 + {
1.2287 + numSuccessful++;
1.2288 + returnCode = ptrString.Find(KErrOOM);
1.2289 + if (returnCode > 0)
1.2290 + User::Leave(KErrNoMemory);
1.2291 + }
1.2292 +
1.2293 +
1.2294 + CleanupStack::PopAndDestroy(hBuffer);
1.2295 + CleanupStack::PopAndDestroy(); //theFile
1.2296 + CleanupStack::PopAndDestroy(); //fileSystem
1.2297 +
1.2298 + if (numSuccessful == 1)
1.2299 + return KErrNone;
1.2300 + else
1.2301 + return KErrNotFound;
1.2302 + }
1.2303 +
1.2304 +
1.2305 +
1.2306 +/**
1.2307 +* 030_TagWrite03: Test that flogger handles empty component tag
1.2308 +*/
1.2309 +
1.2310 +CFloggerTest030_TagWrite03::CFloggerTest030_TagWrite03()
1.2311 + {
1.2312 + // Store the name of this test case
1.2313 + SetTestStepName(_L("step_030_TagWrite03"));
1.2314 + }
1.2315 +
1.2316 +
1.2317 +
1.2318 +
1.2319 +CFloggerTest030_TagWrite03::~CFloggerTest030_TagWrite03()
1.2320 + {
1.2321 + }
1.2322 +
1.2323 +
1.2324 +
1.2325 +
1.2326 +TVerdict CFloggerTest030_TagWrite03::doTestStepL( )
1.2327 + {
1.2328 + if ( executeStepL() == KErrNone )
1.2329 + SetTestStepResult(EPass);
1.2330 +
1.2331 + else
1.2332 + SetTestStepResult(EFail);
1.2333 +
1.2334 + User::After(KTimeForDisplay);
1.2335 +
1.2336 +
1.2337 + return TestStepResult();
1.2338 + }
1.2339 +
1.2340 +
1.2341 +TInt CFloggerTest030_TagWrite03::executeStepL(TBool)
1.2342 + {
1.2343 + return KErrGeneral;
1.2344 + }
1.2345 +
1.2346 +TInt CFloggerTest030_TagWrite03::executeStepL()
1.2347 + {
1.2348 +
1.2349 + TInt ret ;
1.2350 + RFileLogger theFlogger;
1.2351 + ret = theFlogger.Connect();
1.2352 +
1.2353 + if ( ret == KErrNone)
1.2354 + {
1.2355 + //Create Log by passing the subsystem and component name as parameters
1.2356 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.2357 + theFlogger.ClearLog();
1.2358 + theFlogger.Close();
1.2359 + RFileLogger::Write(KStdSubsysTag8, KNullDesC8,KTestMessage);
1.2360 + User::After(KTimeToLog);
1.2361 + TRAPD(r, ret = DoTestCheckWriteL());
1.2362 + if (r != KErrNone)
1.2363 + ret = r;
1.2364 + }
1.2365 +
1.2366 + return ret;
1.2367 +
1.2368 + }
1.2369 +
1.2370 +
1.2371 +
1.2372 +
1.2373 +TInt CFloggerTest030_TagWrite03::DoTestCheckWriteL()
1.2374 + {
1.2375 + RFile theFile;
1.2376 + HBufC8 * hBuffer;
1.2377 + TInt listfilesize,returnCode;
1.2378 + RFs fileSystem; //For file operation create a file system
1.2379 + TUint numSuccessful = 0;
1.2380 +
1.2381 +
1.2382 + User::LeaveIfError(fileSystem.Connect());
1.2383 + CleanupClosePushL(fileSystem);
1.2384 +
1.2385 + //Open the file in the read mode
1.2386 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.2387 +
1.2388 + CleanupClosePushL(theFile);
1.2389 +
1.2390 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.2391 +
1.2392 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.2393 + CleanupStack::PushL(hBuffer);
1.2394 +
1.2395 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.2396 +
1.2397 + // Read from position 0: start of file
1.2398 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.2399 +
1.2400 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.2401 + //from the file
1.2402 +
1.2403 + if (returnCode == KErrNotFound)
1.2404 + {
1.2405 + numSuccessful++;
1.2406 + returnCode = ptrString.Find(KErrOOM);
1.2407 + if (returnCode > 0)
1.2408 + User::Leave(KErrNoMemory);
1.2409 + }
1.2410 +
1.2411 +
1.2412 + CleanupStack::PopAndDestroy(hBuffer);
1.2413 + CleanupStack::PopAndDestroy(); //theFile
1.2414 + CleanupStack::PopAndDestroy(); //fileSystem
1.2415 +
1.2416 + if (numSuccessful == 1)
1.2417 + return KErrNone;
1.2418 + else
1.2419 + return KErrNotFound;
1.2420 + }
1.2421 +
1.2422 +
1.2423 +
1.2424 +
1.2425 +/**
1.2426 +* 030_TagWrite04: Test that flogger handles spaces in tags
1.2427 +*/
1.2428 +
1.2429 +CFloggerTest030_TagWrite04::CFloggerTest030_TagWrite04()
1.2430 + {
1.2431 + // Store the name of this test case
1.2432 + SetTestStepName(_L("step_030_TagWrite04"));
1.2433 + }
1.2434 +
1.2435 +
1.2436 +
1.2437 +
1.2438 +CFloggerTest030_TagWrite04::~CFloggerTest030_TagWrite04()
1.2439 + {
1.2440 + }
1.2441 +
1.2442 +
1.2443 +
1.2444 +
1.2445 +TVerdict CFloggerTest030_TagWrite04::doTestStepL( )
1.2446 + {
1.2447 + if ( executeStepL() == KErrNone )
1.2448 + SetTestStepResult(EPass);
1.2449 +
1.2450 + else
1.2451 + SetTestStepResult(EFail);
1.2452 +
1.2453 + User::After(KTimeForDisplay);
1.2454 +
1.2455 +
1.2456 + return TestStepResult();
1.2457 + }
1.2458 +
1.2459 +
1.2460 +TInt CFloggerTest030_TagWrite04::executeStepL(TBool)
1.2461 + {
1.2462 + return KErrGeneral;
1.2463 + }
1.2464 +
1.2465 +TInt CFloggerTest030_TagWrite04::executeStepL()
1.2466 + {
1.2467 +
1.2468 + TInt ret ;
1.2469 + RFileLogger theFlogger;
1.2470 + ret = theFlogger.Connect();
1.2471 +
1.2472 + if ( ret == KErrNone)
1.2473 + {
1.2474 + //Create Log by passing the subsystem and component name as parameters
1.2475 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.2476 + theFlogger.ClearLog();
1.2477 + theFlogger.Close();
1.2478 + RFileLogger::Write(KStdSubsysTag8, KCompTagWithSpaceChars8,KTestMessage);
1.2479 + User::After(KTimeToLog);
1.2480 + TRAPD(r, ret = DoTestCheckWriteL());
1.2481 + if (r != KErrNone)
1.2482 + ret = r;
1.2483 + }
1.2484 +
1.2485 + return ret;
1.2486 +
1.2487 + }
1.2488 +
1.2489 +
1.2490 +
1.2491 +
1.2492 +TInt CFloggerTest030_TagWrite04::DoTestCheckWriteL()
1.2493 + {
1.2494 + RFile theFile;
1.2495 + HBufC8 * hBuffer;
1.2496 + TInt listfilesize,returnCode;
1.2497 + RFs fileSystem; //For file operation create a file system
1.2498 + TUint numSuccessful = 0;
1.2499 +
1.2500 +
1.2501 + User::LeaveIfError(fileSystem.Connect());
1.2502 + CleanupClosePushL(fileSystem);
1.2503 +
1.2504 + //Open the file in the read mode
1.2505 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.2506 +
1.2507 + CleanupClosePushL(theFile);
1.2508 +
1.2509 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.2510 +
1.2511 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.2512 + CleanupStack::PushL(hBuffer);
1.2513 +
1.2514 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.2515 +
1.2516 + // Read from position 0: start of file
1.2517 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.2518 +
1.2519 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.2520 + //from the file
1.2521 +
1.2522 + if (returnCode == KErrNotFound)
1.2523 + {
1.2524 + numSuccessful++;
1.2525 + returnCode = ptrString.Find(KErrOOM);
1.2526 + if (returnCode > 0)
1.2527 + User::Leave(KErrNoMemory);
1.2528 + }
1.2529 +
1.2530 +
1.2531 + CleanupStack::PopAndDestroy(hBuffer);
1.2532 + CleanupStack::PopAndDestroy(); //theFile
1.2533 + CleanupStack::PopAndDestroy(); //fileSystem
1.2534 +
1.2535 + if (numSuccessful == 1)
1.2536 + return KErrNone;
1.2537 + else
1.2538 + return KErrNotFound;
1.2539 + }
1.2540 +
1.2541 +
1.2542 +
1.2543 +
1.2544 +
1.2545 +/**
1.2546 +* 030_TagWrite05: Test that flogger handles punctuation in tags
1.2547 +*/
1.2548 +
1.2549 +CFloggerTest030_TagWrite05::CFloggerTest030_TagWrite05()
1.2550 + {
1.2551 + // Store the name of this test case
1.2552 + SetTestStepName(_L("step_030_TagWrite05"));
1.2553 + }
1.2554 +
1.2555 +
1.2556 +
1.2557 +
1.2558 +CFloggerTest030_TagWrite05::~CFloggerTest030_TagWrite05()
1.2559 + {
1.2560 + }
1.2561 +
1.2562 +
1.2563 +
1.2564 +
1.2565 +TVerdict CFloggerTest030_TagWrite05::doTestStepL( )
1.2566 + {
1.2567 + if ( executeStepL() == KErrNone )
1.2568 + SetTestStepResult(EPass);
1.2569 +
1.2570 + else
1.2571 + SetTestStepResult(EFail);
1.2572 +
1.2573 + User::After(KTimeForDisplay);
1.2574 +
1.2575 +
1.2576 + return TestStepResult();
1.2577 + }
1.2578 +
1.2579 +TInt CFloggerTest030_TagWrite05::executeStepL(TBool)
1.2580 + {
1.2581 + return KErrGeneral;
1.2582 + }
1.2583 +
1.2584 +
1.2585 +TInt CFloggerTest030_TagWrite05::executeStepL()
1.2586 + {
1.2587 +
1.2588 + TInt ret ;
1.2589 + RFileLogger theFlogger;
1.2590 + ret = theFlogger.Connect();
1.2591 +
1.2592 + if ( ret == KErrNone)
1.2593 + {
1.2594 + //Create Log by passing the subsystem and component name as parameters
1.2595 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.2596 + theFlogger.ClearLog();
1.2597 + theFlogger.Close();
1.2598 + RFileLogger::Write(KSubsysTagWithPunctuationChars8, KCompTagWithPunctuationChars8,KTestMessage);
1.2599 + User::After(KTimeToLog);
1.2600 + TRAPD(r, ret = DoTestCheckWriteL());
1.2601 + if (r != KErrNone)
1.2602 + ret = r;
1.2603 + }
1.2604 +
1.2605 + return ret;
1.2606 +
1.2607 + }
1.2608 +
1.2609 +
1.2610 +
1.2611 +
1.2612 +TInt CFloggerTest030_TagWrite05::DoTestCheckWriteL()
1.2613 + {
1.2614 + RFile theFile;
1.2615 + HBufC8 * hBuffer;
1.2616 + TInt listfilesize,returnCode;
1.2617 + RFs fileSystem; //For file operation create a file system
1.2618 + TUint numSuccessful = 0;
1.2619 +
1.2620 +
1.2621 + User::LeaveIfError(fileSystem.Connect());
1.2622 + CleanupClosePushL(fileSystem);
1.2623 +
1.2624 + //Open the file in the read mode
1.2625 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.2626 +
1.2627 + CleanupClosePushL(theFile);
1.2628 +
1.2629 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.2630 +
1.2631 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.2632 + CleanupStack::PushL(hBuffer);
1.2633 +
1.2634 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.2635 +
1.2636 + // Read from position 0: start of file
1.2637 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.2638 +
1.2639 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.2640 + //from the file
1.2641 +
1.2642 + if (returnCode == KErrNotFound)
1.2643 + {
1.2644 + numSuccessful++;
1.2645 + returnCode = ptrString.Find(KErrOOM);
1.2646 + if (returnCode > 0)
1.2647 + User::Leave(KErrNoMemory);
1.2648 + }
1.2649 +
1.2650 +
1.2651 + CleanupStack::PopAndDestroy(hBuffer);
1.2652 + CleanupStack::PopAndDestroy(); //theFile
1.2653 + CleanupStack::PopAndDestroy(); //fileSystem
1.2654 +
1.2655 + if (numSuccessful == 1)
1.2656 + return KErrNone;
1.2657 + else
1.2658 + return KErrNotFound;
1.2659 + }
1.2660 +
1.2661 +
1.2662 +/**
1.2663 +* 030_TagWrite06: Test that flogger handles long tags
1.2664 +*/
1.2665 +
1.2666 +CFloggerTest030_TagWrite06::CFloggerTest030_TagWrite06()
1.2667 + {
1.2668 + // Store the name of this test case
1.2669 + SetTestStepName(_L("step_030_TagWrite06"));
1.2670 + }
1.2671 +
1.2672 +
1.2673 +
1.2674 +
1.2675 +CFloggerTest030_TagWrite06::~CFloggerTest030_TagWrite06()
1.2676 + {
1.2677 + }
1.2678 +
1.2679 +
1.2680 +
1.2681 +
1.2682 +TVerdict CFloggerTest030_TagWrite06::doTestStepL( )
1.2683 + {
1.2684 + if ( executeStepL() == KErrNone )
1.2685 + SetTestStepResult(EPass);
1.2686 +
1.2687 + else
1.2688 + SetTestStepResult(EFail);
1.2689 +
1.2690 + User::After(KTimeForDisplay);
1.2691 +
1.2692 +
1.2693 + return TestStepResult();
1.2694 + }
1.2695 +
1.2696 +
1.2697 +TInt CFloggerTest030_TagWrite06::executeStepL(TBool)
1.2698 + {
1.2699 + return KErrGeneral;
1.2700 + }
1.2701 +
1.2702 +TInt CFloggerTest030_TagWrite06::executeStepL()
1.2703 + {
1.2704 +
1.2705 + TInt ret ;
1.2706 + RFileLogger theFlogger;
1.2707 + ret = theFlogger.Connect();
1.2708 +
1.2709 + if ( ret == KErrNone)
1.2710 + {
1.2711 + //Create Log by passing the subsystem and component name as parameters
1.2712 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.2713 + theFlogger.ClearLog();
1.2714 + theFlogger.Close();
1.2715 + RFileLogger::Write(KSubsysTag16char8, KCompTag16char8,KTestMessage8);
1.2716 + User::After(KTimeToLog);
1.2717 + TRAPD(r, ret = DoTestCheckWriteL());
1.2718 + if (r != KErrNone)
1.2719 + ret = r;
1.2720 + }
1.2721 +
1.2722 + return ret;
1.2723 +
1.2724 + }
1.2725 +
1.2726 +
1.2727 +
1.2728 +
1.2729 +TInt CFloggerTest030_TagWrite06::DoTestCheckWriteL()
1.2730 + {
1.2731 + RFile theFile;
1.2732 + HBufC8 * hBuffer;
1.2733 + TInt listfilesize,returnCode;
1.2734 + RFs fileSystem; //For file operation create a file system
1.2735 + TUint numSuccessful = 0;
1.2736 +
1.2737 +
1.2738 + User::LeaveIfError(fileSystem.Connect());
1.2739 + CleanupClosePushL(fileSystem);
1.2740 +
1.2741 + //Open the file in the read mode
1.2742 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.2743 +
1.2744 + CleanupClosePushL(theFile);
1.2745 +
1.2746 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.2747 +
1.2748 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.2749 + CleanupStack::PushL(hBuffer);
1.2750 +
1.2751 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.2752 +
1.2753 + // Read from position 0: start of file
1.2754 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.2755 +
1.2756 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.2757 + //from the file
1.2758 +
1.2759 + if (returnCode > 0)
1.2760 + {
1.2761 + numSuccessful++;
1.2762 + }
1.2763 + else if (returnCode == KErrNotFound)
1.2764 + {
1.2765 + returnCode = ptrString.Find(KErrOOM);
1.2766 + if (returnCode > 0)
1.2767 + User::Leave(KErrNoMemory);
1.2768 + }
1.2769 +
1.2770 +
1.2771 + CleanupStack::PopAndDestroy(hBuffer);
1.2772 + CleanupStack::PopAndDestroy(); //theFile
1.2773 + CleanupStack::PopAndDestroy(); //fileSystem
1.2774 +
1.2775 + if (numSuccessful == 1)
1.2776 + return KErrNone;
1.2777 + else
1.2778 + return KErrNotFound;
1.2779 + }
1.2780 +
1.2781 +
1.2782 +
1.2783 +
1.2784 +/**
1.2785 +* 030_TagWrite07: Test that flogger handles long tags
1.2786 +*/
1.2787 +
1.2788 +CFloggerTest030_TagWrite07::CFloggerTest030_TagWrite07()
1.2789 + {
1.2790 + // Store the name of this test case
1.2791 + SetTestStepName(_L("step_030_TagWrite07"));
1.2792 + }
1.2793 +
1.2794 +
1.2795 +
1.2796 +
1.2797 +CFloggerTest030_TagWrite07::~CFloggerTest030_TagWrite07()
1.2798 + {
1.2799 + }
1.2800 +
1.2801 +
1.2802 +
1.2803 +
1.2804 +TVerdict CFloggerTest030_TagWrite07::doTestStepL( )
1.2805 + {
1.2806 + if ( executeStepL() == KErrNone )
1.2807 + SetTestStepResult(EPass);
1.2808 +
1.2809 + else
1.2810 + SetTestStepResult(EFail);
1.2811 +
1.2812 + User::After(KTimeForDisplay);
1.2813 +
1.2814 +
1.2815 + return TestStepResult();
1.2816 + }
1.2817 +
1.2818 +
1.2819 +TInt CFloggerTest030_TagWrite07::executeStepL(TBool)
1.2820 + {
1.2821 + return KErrGeneral;
1.2822 + }
1.2823 +
1.2824 +TInt CFloggerTest030_TagWrite07::executeStepL()
1.2825 + {
1.2826 +
1.2827 + TInt ret ;
1.2828 + RFileLogger theFlogger;
1.2829 + ret = theFlogger.Connect();
1.2830 +
1.2831 + if ( ret == KErrNone)
1.2832 + {
1.2833 + //Create Log by passing the subsystem and component name as parameters
1.2834 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.2835 + theFlogger.ClearLog();
1.2836 + theFlogger.Close();
1.2837 + RFileLogger::Write(KSubsysTag17char8, KCompTag17char8,KTestMessage8);
1.2838 + User::After(KTimeToLog);
1.2839 + TRAPD(r, ret = DoTestCheckWriteL());
1.2840 + if (r != KErrNone)
1.2841 + ret = r;
1.2842 + }
1.2843 +
1.2844 + return ret;
1.2845 +
1.2846 + }
1.2847 +
1.2848 +
1.2849 +
1.2850 +
1.2851 +TInt CFloggerTest030_TagWrite07::DoTestCheckWriteL()
1.2852 + {
1.2853 + RFile theFile;
1.2854 + HBufC8 * hBuffer;
1.2855 + TInt listfilesize,returnCode;
1.2856 + RFs fileSystem; //For file operation create a file system
1.2857 + TUint numSuccessful = 0;
1.2858 +
1.2859 +
1.2860 + User::LeaveIfError(fileSystem.Connect());
1.2861 + CleanupClosePushL(fileSystem);
1.2862 +
1.2863 + //Open the file in the read mode
1.2864 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.2865 +
1.2866 + CleanupClosePushL(theFile);
1.2867 +
1.2868 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.2869 +
1.2870 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.2871 + CleanupStack::PushL(hBuffer);
1.2872 +
1.2873 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.2874 +
1.2875 + // Read from position 0: start of file
1.2876 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.2877 +
1.2878 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.2879 + //from the file
1.2880 +
1.2881 + if (returnCode > 0)
1.2882 + {
1.2883 + numSuccessful++;
1.2884 + }
1.2885 + else if (returnCode == KErrNotFound)
1.2886 + {
1.2887 + returnCode = ptrString.Find(KErrOOM);
1.2888 + if (returnCode > 0)
1.2889 + User::Leave(KErrNoMemory);
1.2890 + }
1.2891 +
1.2892 + // We expect to see the string "subsystem0123456" but not "subsystem01234567"
1.2893 + returnCode = ptrString.Find(KSubsysTag16char8); //find the test descriptor in the buffer read
1.2894 +
1.2895 + if (returnCode > 0)
1.2896 + {
1.2897 + numSuccessful++;
1.2898 + }
1.2899 +
1.2900 + returnCode = ptrString.Find(KSubsysTag17char8); //find the test descriptor in the buffer read
1.2901 +
1.2902 + if (returnCode == KErrNotFound)
1.2903 + {
1.2904 + numSuccessful++;
1.2905 + }
1.2906 +
1.2907 + CleanupStack::PopAndDestroy(hBuffer);
1.2908 + CleanupStack::PopAndDestroy(); //theFile
1.2909 + CleanupStack::PopAndDestroy(); //fileSystem
1.2910 +
1.2911 + if (numSuccessful == 3)
1.2912 + return KErrNone;
1.2913 + else
1.2914 + return KErrNotFound;
1.2915 + }
1.2916 +
1.2917 +
1.2918 +
1.2919 +
1.2920 +/**
1.2921 +* 030_TagWrite08: Test that flogger handles very long tags
1.2922 +*/
1.2923 +
1.2924 +CFloggerTest030_TagWrite08::CFloggerTest030_TagWrite08()
1.2925 + {
1.2926 + // Store the name of this test case
1.2927 + SetTestStepName(_L("step_030_TagWrite08"));
1.2928 + }
1.2929 +
1.2930 +
1.2931 +
1.2932 +
1.2933 +CFloggerTest030_TagWrite08::~CFloggerTest030_TagWrite08()
1.2934 + {
1.2935 + }
1.2936 +
1.2937 +
1.2938 +
1.2939 +
1.2940 +TVerdict CFloggerTest030_TagWrite08::doTestStepL( )
1.2941 + {
1.2942 + if ( executeStepL() == KErrNone )
1.2943 + SetTestStepResult(EPass);
1.2944 +
1.2945 + else
1.2946 + SetTestStepResult(EFail);
1.2947 +
1.2948 + User::After(KTimeForDisplay);
1.2949 +
1.2950 +
1.2951 + return TestStepResult();
1.2952 + }
1.2953 +
1.2954 +
1.2955 +TInt CFloggerTest030_TagWrite08::executeStepL(TBool)
1.2956 + {
1.2957 + return KErrGeneral;
1.2958 + }
1.2959 +
1.2960 +TInt CFloggerTest030_TagWrite08::executeStepL()
1.2961 + {
1.2962 +
1.2963 + TInt ret ;
1.2964 + RFileLogger theFlogger;
1.2965 + ret = theFlogger.Connect();
1.2966 +
1.2967 + if ( ret == KErrNone)
1.2968 + {
1.2969 + theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
1.2970 + theFlogger.ClearLog();
1.2971 + theFlogger.Close();
1.2972 + RFileLogger::Write(KSubsysTag66char8, KCompTag66char8,KTestMessage);
1.2973 + User::After(KTimeToLog);
1.2974 + TRAPD(r, ret = DoTestCheckWriteL());
1.2975 + if (r != KErrNone)
1.2976 + ret = r;
1.2977 + }
1.2978 +
1.2979 + return ret;
1.2980 +
1.2981 + }
1.2982 +
1.2983 +
1.2984 +
1.2985 +
1.2986 +TInt CFloggerTest030_TagWrite08::DoTestCheckWriteL()
1.2987 + {
1.2988 + RFile theFile;
1.2989 + HBufC8 * hBuffer;
1.2990 + TInt listfilesize,returnCode;
1.2991 + RFs fileSystem; //For file operation create a file system
1.2992 + TUint numSuccessful = 0;
1.2993 +
1.2994 +
1.2995 + User::LeaveIfError(fileSystem.Connect());
1.2996 + CleanupClosePushL(fileSystem);
1.2997 +
1.2998 + //Open the file in the read mode
1.2999 + User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
1.3000 +
1.3001 + CleanupClosePushL(theFile);
1.3002 +
1.3003 + User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
1.3004 +
1.3005 + hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
1.3006 + CleanupStack::PushL(hBuffer);
1.3007 +
1.3008 + TPtr8 ptrString = hBuffer->Des(); ; //To hold the buffer
1.3009 +
1.3010 + // Read from position 0: start of file
1.3011 + User::LeaveIfError(returnCode = theFile.Read(ptrString));
1.3012 +
1.3013 + returnCode = ptrString.Find(KTestMessage8); //find the test descriptor in the buffer read
1.3014 + //from the file
1.3015 +
1.3016 + if (returnCode > 0)
1.3017 + {
1.3018 + numSuccessful++;
1.3019 + }
1.3020 + else if (returnCode == KErrNotFound)
1.3021 + {
1.3022 + returnCode = ptrString.Find(KErrOOM);
1.3023 + if (returnCode > 0)
1.3024 + User::Leave(KErrNoMemory);
1.3025 + }
1.3026 +
1.3027 + // We expect to see the string "subsystem0123456" but not "subsystem01234567"
1.3028 + returnCode = ptrString.Find(KSubsysTag16char8); //find the test descriptor in the buffer read
1.3029 +
1.3030 + if (returnCode > 0)
1.3031 + {
1.3032 + numSuccessful++;
1.3033 + }
1.3034 +
1.3035 + CleanupStack::PopAndDestroy(hBuffer);
1.3036 + CleanupStack::PopAndDestroy(); //theFile
1.3037 + CleanupStack::PopAndDestroy(); //fileSystem
1.3038 +
1.3039 + if (numSuccessful == 2)
1.3040 + return KErrNone;
1.3041 + else
1.3042 + return KErrNotFound;
1.3043 + }
1.3044 +
1.3045 +