1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/loggingservices/eventlogger/test/src/t_logevent.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,904 @@
1.4 +// Copyright (c) 2002-2010 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 +//
1.18 +
1.19 +#include <s32file.h>
1.20 +#include "t_logutil2.h"
1.21 +#include <s32mem.h>
1.22 +
1.23 +RTest TheTest(_L("t_logevent"));
1.24 +
1.25 +TBool CompareEvents(const CLogEvent& aLeft, const CLogEvent& aRight)
1.26 + {
1.27 + TBool ret = aLeft.Data() == aRight.Data();
1.28 + ret = ret && aLeft.Description() == aRight.Description();
1.29 + ret = ret && aLeft.Direction() == aRight.Direction();
1.30 + ret = ret && aLeft.Duration() == aRight.Duration();
1.31 + ret = ret && aLeft.DurationType() == aRight.DurationType();
1.32 + ret = ret && aLeft.EventType() == aRight.EventType();
1.33 + ret = ret && aLeft.Flags() == aRight.Flags();
1.34 + ret = ret && aLeft.Id() == aRight.Id();
1.35 + ret = ret && aLeft.Link() == aRight.Link();
1.36 + ret = ret && aLeft.Number() == aRight.Number();
1.37 + ret = ret && aLeft.RemoteParty() == aRight.RemoteParty();
1.38 + ret = ret && aLeft.Status() == aRight.Status();
1.39 + ret = ret && aLeft.Subject() == aRight.Subject();
1.40 + ret = ret && aLeft.Time() == aRight.Time();
1.41 + return ret;
1.42 + }
1.43 +
1.44 +void TestStoreL(const CLogEvent& aEvent)
1.45 + {
1.46 +// const TInt size = aEvent.Size();
1.47 +
1.48 + //Store
1.49 + CBufFlat* buf = CBufFlat::NewL(0x100);
1.50 + CleanupStack::PushL(buf);
1.51 + RBufWriteStream write(*buf);
1.52 + write << aEvent;
1.53 + write.CommitL();
1.54 +
1.55 + //Restore
1.56 + CLogEvent* event = CLogEvent::NewL();
1.57 + CleanupStack::PushL(event);
1.58 + RBufReadStream read(*buf);
1.59 + read >> *event;
1.60 +
1.61 + TBool ret = CompareEvents(aEvent, *event);
1.62 + TEST(ret);
1.63 +
1.64 + CleanupStack::PopAndDestroy(2);
1.65 + }
1.66 +
1.67 +/**
1.68 +@SYMTestCaseID SYSLIB-LOGENG-CT-1008
1.69 +@SYMTestCaseDesc Tests for writing different events to a store
1.70 +@SYMTestPriority High
1.71 +@SYMTestActions Calls up TestStoreL() function
1.72 +@SYMTestExpectedResults Test must not fail
1.73 +@SYMREQ REQ0000
1.74 +*/
1.75 +LOCAL_C void TestEventL()
1.76 + {
1.77 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1008 "));
1.78 + CLogEvent* event1 = CLogEvent::NewL();
1.79 + CleanupStack::PushL(event1);
1.80 +
1.81 + // Event Id
1.82 + TEST(event1->Id() == KLogNullId);
1.83 + TestStoreL(*event1);
1.84 +
1.85 + event1->SetId(0x12345678);
1.86 + TEST(event1->Id() == 0x12345678);
1.87 + TestStoreL(*event1);
1.88 +
1.89 + event1->SetId(KMaxTInt32);
1.90 + TEST(event1->Id() == KMaxTInt32);
1.91 + TestStoreL(*event1);
1.92 +
1.93 + event1->SetId(0);
1.94 + TEST(event1->Id() == 0);
1.95 + TestStoreL(*event1);
1.96 +
1.97 + // Event type
1.98 + event1->SetEventType(TUid::Null());
1.99 + TestStoreL(*event1);
1.100 +
1.101 + event1->SetEventType(TUid::Uid(0x12345678));
1.102 + TEST(event1->EventType() == TUid::Uid(0x12345678));
1.103 + TestStoreL(*event1);
1.104 +
1.105 + event1->SetEventType(TUid::Uid(KMaxTInt32));
1.106 + TEST(event1->EventType() == TUid::Uid(KMaxTInt32));
1.107 + TestStoreL(*event1);
1.108 +
1.109 + event1->SetEventType(TUid::Null());
1.110 + TEST(event1->EventType() == TUid::Null());
1.111 + TestStoreL(*event1);
1.112 +
1.113 + // Remote Party
1.114 + TEST(event1->RemoteParty() == KNullDesC);
1.115 + TestStoreL(*event1);
1.116 +
1.117 + HBufC* buf = TestUtils::CreateBufLC(KLogMaxRemotePartyLength / 2);
1.118 + event1->SetRemoteParty(buf->Des());
1.119 + TEST(event1->RemoteParty() == buf->Des());
1.120 + CleanupStack::PopAndDestroy(); // buf
1.121 + TestStoreL(*event1);
1.122 +
1.123 + buf = TestUtils::CreateBufLC(KLogMaxRemotePartyLength);
1.124 + event1->SetRemoteParty(buf->Des());
1.125 + TEST(event1->RemoteParty() == buf->Des());
1.126 + CleanupStack::PopAndDestroy(); // buf
1.127 + TestStoreL(*event1);
1.128 +
1.129 + buf = TestUtils::CreateBufLC(KLogMaxRemotePartyLength * 2);
1.130 + event1->SetRemoteParty(buf->Des());
1.131 + TEST(event1->RemoteParty() == buf->Des().Left(KLogMaxRemotePartyLength));
1.132 + CleanupStack::PopAndDestroy(); // buf
1.133 + TestStoreL(*event1);
1.134 +
1.135 + event1->SetRemoteParty(KNullDesC);
1.136 + TEST(event1->RemoteParty() == KNullDesC);
1.137 + TestStoreL(*event1);
1.138 +
1.139 + // Direction
1.140 + TEST(event1->Direction() == KNullDesC);
1.141 + TestStoreL(*event1);
1.142 +
1.143 + buf = TestUtils::CreateBufLC(KLogMaxDirectionLength / 2);
1.144 + event1->SetDirection(buf->Des());
1.145 + TEST(event1->Direction() == buf->Des());
1.146 + CleanupStack::PopAndDestroy(); // buf
1.147 + TestStoreL(*event1);
1.148 +
1.149 + buf = TestUtils::CreateBufLC(KLogMaxDirectionLength);
1.150 + event1->SetDirection(buf->Des());
1.151 + TEST(event1->Direction() == buf->Des());
1.152 + CleanupStack::PopAndDestroy(); // buf
1.153 + TestStoreL(*event1);
1.154 +
1.155 + buf = TestUtils::CreateBufLC(KLogMaxDirectionLength * 2);
1.156 + event1->SetDirection(buf->Des());
1.157 + TEST(event1->Direction() == buf->Des().Left(KLogMaxDirectionLength));
1.158 + CleanupStack::PopAndDestroy(); // buf
1.159 + TestStoreL(*event1);
1.160 +
1.161 + event1->SetDirection(KNullDesC);
1.162 + TEST(event1->Direction() == KNullDesC);
1.163 + TestStoreL(*event1);
1.164 +
1.165 + // Time
1.166 + TTime time;
1.167 +
1.168 + time.UniversalTime();
1.169 + event1->SetTime(time);
1.170 + TEST(event1->Time() == time);
1.171 + TestStoreL(*event1);
1.172 +
1.173 + time.HomeTime();
1.174 + event1->SetTime(time);
1.175 + TEST(event1->Time() == time);
1.176 + TestStoreL(*event1);
1.177 +
1.178 + // Duration Type
1.179 + TEST(event1->DurationType() == KLogNullDurationType);
1.180 +
1.181 + event1->SetDurationType(0xf);
1.182 + TEST(event1->DurationType() == 0xf);
1.183 + TestStoreL(*event1);
1.184 +
1.185 + event1->SetDurationType(KMaxTInt8);
1.186 + TEST(event1->DurationType() == KMaxTInt8);
1.187 + TestStoreL(*event1);
1.188 +
1.189 + event1->SetDurationType(KLogNullDurationType);
1.190 + TEST(event1->DurationType() == KLogNullDurationType);
1.191 + TestStoreL(*event1);
1.192 +
1.193 + // Duration
1.194 + TEST(event1->Duration() == KLogNullDuration);
1.195 +
1.196 + event1->SetDuration(0x12345678);
1.197 + TEST(event1->Duration() == 0x12345678);
1.198 + TestStoreL(*event1);
1.199 +
1.200 + event1->SetDuration(KMaxTUint32);
1.201 + TEST(event1->Duration() == KMaxTUint32);
1.202 + TestStoreL(*event1);
1.203 +
1.204 + event1->SetDuration(KLogNullDuration);
1.205 + TEST(event1->Duration() == KLogNullDuration);
1.206 + TestStoreL(*event1);
1.207 +
1.208 + // Status
1.209 + TEST(event1->Status() == KNullDesC);
1.210 +
1.211 + buf = TestUtils::CreateBufLC(KLogMaxStatusLength / 2);
1.212 + event1->SetStatus(buf->Des());
1.213 + TEST(event1->Status() == buf->Des());
1.214 + CleanupStack::PopAndDestroy(); // buf
1.215 + TestStoreL(*event1);
1.216 +
1.217 + buf = TestUtils::CreateBufLC(KLogMaxStatusLength);
1.218 + event1->SetStatus(buf->Des());
1.219 + TEST(event1->Status() == buf->Des());
1.220 + CleanupStack::PopAndDestroy(); // buf
1.221 + TestStoreL(*event1);
1.222 +
1.223 + buf = TestUtils::CreateBufLC(KLogMaxStatusLength * 2);
1.224 + event1->SetStatus(buf->Des());
1.225 + TEST(event1->Status() == buf->Des().Left(KLogMaxStatusLength));
1.226 + CleanupStack::PopAndDestroy(); // buf
1.227 + TestStoreL(*event1);
1.228 +
1.229 + event1->SetStatus(KNullDesC);
1.230 + TEST(event1->Status() == KNullDesC);
1.231 + TestStoreL(*event1);
1.232 +
1.233 + // Subject
1.234 + TEST(event1->Subject() == KNullDesC);
1.235 +
1.236 + buf = TestUtils::CreateBufLC(KLogMaxSubjectLength / 2);
1.237 + event1->SetSubject(buf->Des());
1.238 + TEST(event1->Subject() == buf->Des());
1.239 + CleanupStack::PopAndDestroy(); // buf
1.240 + TestStoreL(*event1);
1.241 +
1.242 + buf = TestUtils::CreateBufLC(KLogMaxSubjectLength);
1.243 + event1->SetSubject(buf->Des());
1.244 + TEST(event1->Subject() == buf->Des());
1.245 + CleanupStack::PopAndDestroy(); // buf
1.246 + TestStoreL(*event1);
1.247 +
1.248 + buf = TestUtils::CreateBufLC(KLogMaxSubjectLength * 2);
1.249 + event1->SetSubject(buf->Des());
1.250 + TEST(event1->Subject() == buf->Des().Left(KLogMaxSubjectLength));
1.251 + CleanupStack::PopAndDestroy(); // buf
1.252 + TestStoreL(*event1);
1.253 +
1.254 + event1->SetSubject(KNullDesC);
1.255 + TEST(event1->Subject() == KNullDesC);
1.256 + TestStoreL(*event1);
1.257 +
1.258 + // Number
1.259 + TEST(event1->Number() == KNullDesC);
1.260 +
1.261 + buf = TestUtils::CreateBufLC(KLogMaxNumberLength / 2);
1.262 + event1->SetNumber(buf->Des());
1.263 + TEST(event1->Number() == buf->Des());
1.264 + CleanupStack::PopAndDestroy(); // buf
1.265 + TestStoreL(*event1);
1.266 +
1.267 + buf = TestUtils::CreateBufLC(KLogMaxNumberLength);
1.268 + event1->SetNumber(buf->Des());
1.269 + TEST(event1->Number() == buf->Des());
1.270 + CleanupStack::PopAndDestroy(); // buf
1.271 + TestStoreL(*event1);
1.272 +
1.273 + buf = TestUtils::CreateBufLC(KLogMaxNumberLength * 2);
1.274 + event1->SetNumber(buf->Des());
1.275 + TEST(event1->Number() == buf->Des().Left(KLogMaxNumberLength));
1.276 + CleanupStack::PopAndDestroy(); // buf
1.277 + TestStoreL(*event1);
1.278 +
1.279 + event1->SetNumber(KNullDesC);
1.280 + TEST(event1->Number() == KNullDesC);
1.281 + TestStoreL(*event1);
1.282 +
1.283 + // Contact
1.284 + TEST(event1->Contact() == KLogNullContactId);
1.285 +
1.286 + event1->SetContact(0x12345678);
1.287 + TEST(event1->Contact() == 0x12345678);
1.288 + TestStoreL(*event1);
1.289 +
1.290 + event1->SetContact(KMaxTInt32);
1.291 + TEST(event1->Contact() == KMaxTInt32);
1.292 + TestStoreL(*event1);
1.293 +
1.294 + event1->SetContact(KLogNullContactId);
1.295 + TEST(event1->Contact() == KLogNullContactId);
1.296 + TestStoreL(*event1);
1.297 +
1.298 + event1->SetContact(KMinTInt32);
1.299 + TEST(event1->Contact() == KMinTInt32);
1.300 + TestStoreL(*event1);
1.301 +
1.302 + // Link
1.303 + TEST(event1->Link() == KLogNullLink);
1.304 +
1.305 + event1->SetLink(0x12345678);
1.306 + TEST(event1->Link() == 0x12345678);
1.307 + TestStoreL(*event1);
1.308 +
1.309 + event1->SetLink(KMaxTUint32);
1.310 + TEST(event1->Link() == KMaxTUint32);
1.311 + TestStoreL(*event1);
1.312 +
1.313 + event1->SetLink(KLogNullLink);
1.314 + TEST(event1->Link() == KLogNullLink);
1.315 +
1.316 + // Description
1.317 + TEST(event1->Description() == KNullDesC);
1.318 +
1.319 + buf = TestUtils::CreateBufLC(KLogMaxDescriptionLength / 2);
1.320 + event1->SetDescription(buf->Des());
1.321 + TEST(event1->Description() == buf->Des());
1.322 + CleanupStack::PopAndDestroy(); // buf
1.323 + TestStoreL(*event1);
1.324 +
1.325 + buf = TestUtils::CreateBufLC(KLogMaxDescriptionLength);
1.326 + event1->SetDescription(buf->Des());
1.327 + TEST(event1->Description() == buf->Des());
1.328 + CleanupStack::PopAndDestroy(); // buf
1.329 + TestStoreL(*event1);
1.330 +
1.331 + buf = TestUtils::CreateBufLC(KLogMaxDescriptionLength * 2);
1.332 + event1->SetDescription(buf->Des());
1.333 + TEST(event1->Description() == buf->Des().Left(KLogMaxDescriptionLength));
1.334 + CleanupStack::PopAndDestroy(); // buf
1.335 + TestStoreL(*event1);
1.336 +
1.337 + event1->SetDescription(KNullDesC);
1.338 + TEST(event1->Description() == KNullDesC);
1.339 +
1.340 + // Flags
1.341 + TEST(event1->Flags() == KLogNullFlags);
1.342 + event1->SetFlags(1);
1.343 + TEST(event1->Flags() == 1);
1.344 + TestStoreL(*event1);
1.345 + event1->SetFlags(2);
1.346 + TEST(event1->Flags() == 3);
1.347 + event1->SetFlags(4);
1.348 + TEST(event1->Flags() == 7);
1.349 + event1->SetFlags(8);
1.350 + TEST(event1->Flags() == KLogFlagsMask);
1.351 + event1->ClearFlags(8);
1.352 + TEST(event1->Flags() == 7);
1.353 + event1->ClearFlags(4);
1.354 + TEST(event1->Flags() == 3);
1.355 + event1->ClearFlags(2);
1.356 + TEST(event1->Flags() == 1);
1.357 + event1->ClearFlags(1);
1.358 + TEST(event1->Flags() == KLogNullFlags);
1.359 +
1.360 + event1->SetFlags(1);
1.361 + TEST(event1->Flags() == 1);
1.362 + event1->SetFlags(3);
1.363 + TEST(event1->Flags() == 3);
1.364 + event1->SetFlags(7);
1.365 + TEST(event1->Flags() == 7);
1.366 + event1->SetFlags(15);
1.367 + event1->SetFlags(KLogFlagsMask);
1.368 + TEST(event1->Flags() == KLogFlagsMask);
1.369 + event1->ClearFlags(KLogFlagsMask);
1.370 + TEST(event1->Flags() == KLogNullFlags);
1.371 +
1.372 + event1->SetFlags(0x5);
1.373 + TEST(event1->Flags() == 0x5);
1.374 + event1->SetFlags(0xA);
1.375 + TEST(event1->Flags() == KLogFlagsMask);
1.376 + event1->ClearFlags(0x5);
1.377 + TEST(event1->Flags() == 0xA);
1.378 + event1->ClearFlags(0xA);
1.379 + TEST(event1->Flags() == KLogNullFlags);
1.380 +
1.381 + // Data
1.382 + TEST(event1->Data() == KNullDesC8);
1.383 +
1.384 + HBufC8* buf8;
1.385 +
1.386 + buf8 = TestUtils::CreateBuf8LC(100);
1.387 + event1->SetDataL(buf8->Des());
1.388 + TEST(event1->Data() == buf8->Des());
1.389 + CleanupStack::PopAndDestroy();
1.390 + TestStoreL(*event1);
1.391 +
1.392 + buf8 = TestUtils::CreateBuf8LC(200);
1.393 + event1->SetDataL(buf8->Des());
1.394 + TEST(event1->Data() == buf8->Des());
1.395 + CleanupStack::PopAndDestroy();
1.396 + TestStoreL(*event1);
1.397 +
1.398 + buf8 = TestUtils::CreateBuf8LC(400);
1.399 + event1->SetDataL(buf8->Des());
1.400 + TEST(event1->Data() == buf8->Des());
1.401 + CleanupStack::PopAndDestroy();
1.402 + TestStoreL(*event1);
1.403 +
1.404 + event1->SetDataL(KNullDesC8);
1.405 + TEST(event1->Data() == KNullDesC8);
1.406 +
1.407 + // streaming
1.408 + TFileName storename = _L("c:\\T_LOGEVENT_DATA");
1.409 + TUid uid={0x12345678};
1.410 +
1.411 + // create a store
1.412 + theFs.Delete(storename);
1.413 + CDictionaryFileStore* store = CDictionaryFileStore::OpenLC(theFs, storename, uid);
1.414 +
1.415 + RDictionaryWriteStream write;
1.416 + RDictionaryReadStream read;
1.417 +
1.418 + event1->SetDataL(KNullDesC8);
1.419 +
1.420 + uid.iUid++;
1.421 + write.AssignL(*store, uid);
1.422 + write << event1->Data();
1.423 + write.CommitL();
1.424 + write.Close();
1.425 +
1.426 + read.OpenL(*store, uid);
1.427 + event1->SetDataL(read, 0);
1.428 + read.Close();
1.429 +
1.430 + TEST(event1->Data() == KNullDesC8);
1.431 +
1.432 + buf8 = TestUtils::CreateBuf8LC(100);
1.433 + event1->SetDataL(buf8->Des());
1.434 +
1.435 + uid.iUid++;
1.436 + write.AssignL(*store, uid);
1.437 + write.WriteL(event1->Data());
1.438 + write.CommitL();
1.439 + write.Close();
1.440 +
1.441 + read.OpenL(*store, uid);
1.442 + event1->SetDataL(read, 100);
1.443 + read.Close();
1.444 +
1.445 + TEST(event1->Data() == buf8->Des());
1.446 + CleanupStack::PopAndDestroy(); // buf8
1.447 +
1.448 + buf8 = TestUtils::CreateBuf8LC(200);
1.449 + event1->SetDataL(buf8->Des());
1.450 +
1.451 + uid.iUid++;
1.452 + write.AssignL(*store, uid);
1.453 + write.WriteL(event1->Data());
1.454 + write.CommitL();
1.455 + write.Close();
1.456 +
1.457 + read.OpenL(*store, uid);
1.458 + event1->SetDataL(read, 200);
1.459 + read.Close();
1.460 +
1.461 + TEST(event1->Data() == buf8->Des());
1.462 + CleanupStack::PopAndDestroy(); // buf8
1.463 +
1.464 + buf8 = TestUtils::CreateBuf8LC(400);
1.465 + event1->SetDataL(buf8->Des());
1.466 +
1.467 + uid.iUid++;
1.468 + write.AssignL(*store, uid);
1.469 + write.WriteL(event1->Data());
1.470 + write.CommitL();
1.471 + write.Close();
1.472 +
1.473 + read.OpenL(*store, uid);
1.474 + event1->SetDataL(read, 400);
1.475 + read.Close();
1.476 +
1.477 + TEST(event1->Data() == buf8->Des());
1.478 + CleanupStack::PopAndDestroy(2); // buf8, store
1.479 +
1.480 + // Copying
1.481 + event1->SetId(0x12345678);
1.482 + event1->SetEventType(TUid::Uid(0x12345678));
1.483 +
1.484 + buf = TestUtils::CreateBufLC(KLogMaxRemotePartyLength / 2);
1.485 + event1->SetRemoteParty(buf->Des());
1.486 + TEST(event1->RemoteParty() == buf->Des());
1.487 + CleanupStack::PopAndDestroy(); // buf
1.488 +
1.489 + buf = TestUtils::CreateBufLC(KLogMaxDirectionLength / 2);
1.490 + event1->SetDirection(buf->Des());
1.491 + TEST(event1->Direction() == buf->Des());
1.492 + CleanupStack::PopAndDestroy(); // buf
1.493 +
1.494 + event1->SetDurationType(0xf);
1.495 + TEST(event1->DurationType() == 0xf);
1.496 +
1.497 + event1->SetDuration(0x12345678);
1.498 + TEST(event1->Duration() == 0x12345678);
1.499 +
1.500 + buf = TestUtils::CreateBufLC(KLogMaxStatusLength / 2);
1.501 + event1->SetStatus(buf->Des());
1.502 + TEST(event1->Status() == buf->Des());
1.503 + CleanupStack::PopAndDestroy(); // buf
1.504 +
1.505 + buf = TestUtils::CreateBufLC(KLogMaxSubjectLength / 2);
1.506 + event1->SetSubject(buf->Des());
1.507 + TEST(event1->Subject() == buf->Des());
1.508 + CleanupStack::PopAndDestroy(); // buf
1.509 +
1.510 + buf = TestUtils::CreateBufLC(KLogMaxNumberLength / 2);
1.511 + event1->SetNumber(buf->Des());
1.512 + TEST(event1->Number() == buf->Des());
1.513 + CleanupStack::PopAndDestroy(); // buf
1.514 +
1.515 + event1->SetContact(0x12345678);
1.516 + TEST(event1->Contact() == 0x12345678);
1.517 +
1.518 + event1->SetLink(0x12345678);
1.519 + TEST(event1->Link() == 0x12345678);
1.520 +
1.521 + buf = TestUtils::CreateBufLC(KLogMaxDescriptionLength / 2);
1.522 + event1->SetDescription(buf->Des());
1.523 + TEST(event1->Description() == buf->Des());
1.524 + CleanupStack::PopAndDestroy(); // buf
1.525 +
1.526 + buf8 = TestUtils::CreateBuf8LC(200);
1.527 + event1->SetDataL(buf8->Des());
1.528 + TEST(event1->Data() == buf8->Des());
1.529 + CleanupStack::PopAndDestroy();
1.530 +
1.531 + CLogEvent* event2 = CLogEvent::NewL();
1.532 + CleanupStack::PushL(event2);
1.533 + TEST(!TestUtils::EventsEqual(*event1, *event2));
1.534 +
1.535 + event2->CopyL(*event1);
1.536 + TEST(TestUtils::EventsEqual(*event1, *event2));
1.537 +
1.538 + CleanupStack::PopAndDestroy(); // event2;
1.539 +
1.540 + event2 = CLogEvent::NewL();
1.541 + CleanupStack::PushL(event2);
1.542 + TEST(!TestUtils::EventsEqual(*event1, *event2));
1.543 +
1.544 + event1->CopyL(*event2);
1.545 + TEST(TestUtils::EventsEqual(*event1, *event2));
1.546 +
1.547 + CleanupStack::PopAndDestroy(2); // event1, event2;
1.548 +
1.549 + ::DeleteDataFile(storename);
1.550 + }
1.551 +
1.552 +/**
1.553 +@SYMTestCaseID SYSLIB-LOGENG-CT-1009
1.554 +@SYMTestCaseDesc Tests for CLogEvent::NewL(),SetDataL() functions
1.555 +@SYMTestPriority High
1.556 +@SYMTestActions Tests for creation of log event on heap and
1.557 + test for setting event specific data from the specified stream and try to read the data back.
1.558 + Check for memory errors
1.559 +@SYMTestExpectedResults Test must not fail
1.560 +@SYMREQ REQ0000
1.561 +*/
1.562 +LOCAL_C void TestEventWithHeapFailL()
1.563 + {
1.564 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1009 "));
1.565 +#ifdef _DEBUG
1.566 + TInt failCount = 0;
1.567 +#endif
1.568 + TInt error;
1.569 + TBool finished = EFalse;
1.570 +
1.571 + CLogEvent* event = NULL;
1.572 +
1.573 + while(!finished)
1.574 + {
1.575 + __UHEAP_FAILNEXT(failCount++);
1.576 +
1.577 + TRAP(error, event = CLogEvent::NewL());
1.578 +
1.579 + __UHEAP_RESET;
1.580 +
1.581 + if (error == KErrNone)
1.582 + {
1.583 + finished = ETrue;
1.584 + CleanupStack::PushL(event);
1.585 + }
1.586 + else
1.587 + TEST2(error, KErrNoMemory);
1.588 + }
1.589 +
1.590 + _LIT8(KDataTest1, "01234567890123456789");
1.591 + _LIT8(KDataTest2, "012345678901234567890123456789");
1.592 +
1.593 + finished = EFalse;
1.594 +#ifdef _DEBUG
1.595 + failCount = 0;
1.596 +#endif
1.597 + event->SetDataL(KNullDesC8);
1.598 +
1.599 + while(!finished)
1.600 + {
1.601 + __UHEAP_FAILNEXT(failCount++);
1.602 +
1.603 + TRAP(error, event->SetDataL(KDataTest1));
1.604 +
1.605 + __UHEAP_RESET;
1.606 +
1.607 + if (error == KErrNone)
1.608 + {
1.609 + finished = ETrue;
1.610 + TEST(event->Data() == KDataTest1);
1.611 + }
1.612 + else
1.613 + {
1.614 + TEST2(error, KErrNoMemory);
1.615 + TEST(event->Data() == KNullDesC8);
1.616 + }
1.617 + }
1.618 +
1.619 + finished = EFalse;
1.620 +#ifdef _DEBUG
1.621 + failCount = 0;
1.622 +#endif
1.623 + event->SetDataL(KNullDesC8);
1.624 +
1.625 + while(!finished)
1.626 + {
1.627 + __UHEAP_FAILNEXT(failCount++);
1.628 +
1.629 + TRAP(error, event->SetDataL(KDataTest2));
1.630 +
1.631 + __UHEAP_RESET;
1.632 +
1.633 + if (error == KErrNone)
1.634 + {
1.635 + finished = ETrue;
1.636 + TEST(event->Data() == KDataTest2);
1.637 + }
1.638 + else
1.639 + {
1.640 + TEST2(error, KErrNoMemory);
1.641 + TEST(event->Data() == KNullDesC8);
1.642 + }
1.643 + }
1.644 +
1.645 + finished = EFalse;
1.646 +#ifdef _DEBUG
1.647 + failCount = 0;
1.648 +#endif
1.649 + event->SetDataL(KNullDesC8);
1.650 +
1.651 + // Check we don't get any more failures
1.652 + __UHEAP_FAILNEXT(0);
1.653 + event->SetDataL(KDataTest2);
1.654 + TEST(event->Data() == KDataTest2);
1.655 + event->SetDataL(KDataTest1);
1.656 + TEST(event->Data() == KDataTest1);
1.657 + event->SetDataL(KNullDesC8);
1.658 + TEST(event->Data() == KNullDesC8);
1.659 + __UHEAP_RESET;
1.660 +
1.661 + // streaming
1.662 + TFileName storename = _L("c:\\T_BASIC_DATA");
1.663 + TUid uid={0x12345678};
1.664 +
1.665 + // create a store
1.666 + theFs.Delete(storename);
1.667 + CDictionaryFileStore* store = CDictionaryFileStore::OpenLC(theFs, storename, uid);
1.668 +
1.669 + RDictionaryWriteStream write;
1.670 + RDictionaryReadStream read;
1.671 +
1.672 + uid.iUid++;
1.673 + write.AssignL(*store, uid);
1.674 + write << KNullDesC8;
1.675 + write.CommitL();
1.676 + write.Close();
1.677 +
1.678 + read.OpenL(*store, uid);
1.679 +
1.680 +#ifdef _DEBUG
1.681 + failCount = 0;
1.682 +#endif
1.683 + finished = EFalse;
1.684 +
1.685 + __UHEAP_FAILNEXT(0);
1.686 + event->SetDataL(read, 0);
1.687 + __UHEAP_RESET;
1.688 +
1.689 + read.Close();
1.690 + TEST(event->Data() == KNullDesC8);
1.691 +
1.692 + HBufC8* buf8 = TestUtils::CreateBuf8LC(100);
1.693 +
1.694 + uid.iUid++;
1.695 + write.AssignL(*store, uid);
1.696 + write.WriteL(buf8->Des());
1.697 + write.CommitL();
1.698 + write.Close();
1.699 +
1.700 + read.OpenL(*store, uid);
1.701 +
1.702 + while(!finished)
1.703 + {
1.704 + __UHEAP_FAILNEXT(failCount++);
1.705 +
1.706 + TRAP(error, event->SetDataL(read, 100));
1.707 +
1.708 + __UHEAP_RESET;
1.709 +
1.710 + if (error == KErrNone)
1.711 + {
1.712 + TEST(event->Data() == buf8->Des());
1.713 + read.Close();
1.714 + finished = ETrue;
1.715 + }
1.716 + else
1.717 + {
1.718 + TEST2(error, KErrNoMemory);
1.719 + TEST(event->Data() == KNullDesC8);
1.720 + }
1.721 + }
1.722 +
1.723 + event->SetId(0x12345678);
1.724 + event->SetEventType(TUid::Uid(0x12345678));
1.725 +
1.726 + HBufC* buf = TestUtils::CreateBufLC(KLogMaxRemotePartyLength / 2);
1.727 + event->SetRemoteParty(buf->Des());
1.728 + CleanupStack::PopAndDestroy(); // buf
1.729 +
1.730 + buf = TestUtils::CreateBufLC(KLogMaxDirectionLength / 2);
1.731 + event->SetDirection(buf->Des());
1.732 + CleanupStack::PopAndDestroy(); // buf
1.733 +
1.734 + TTime time;
1.735 +
1.736 + time.UniversalTime();
1.737 + event->SetTime(time);
1.738 + TEST(event->Time() == time);
1.739 +
1.740 + event->SetDurationType(0xf);
1.741 + event->SetDuration(0x12345678);
1.742 +
1.743 + buf = TestUtils::CreateBufLC(KLogMaxStatusLength / 2);
1.744 + event->SetStatus(buf->Des());
1.745 + CleanupStack::PopAndDestroy(); // buf
1.746 +
1.747 + buf = TestUtils::CreateBufLC(KLogMaxSubjectLength / 2);
1.748 + event->SetSubject(buf->Des());
1.749 + CleanupStack::PopAndDestroy(); // buf
1.750 +
1.751 + buf = TestUtils::CreateBufLC(KLogMaxNumberLength / 2);
1.752 + event->SetNumber(buf->Des());
1.753 + CleanupStack::PopAndDestroy(); // buf
1.754 +
1.755 + event->SetContact(0x12345678);
1.756 + event->SetLink(0x12345678);
1.757 +
1.758 + buf = TestUtils::CreateBufLC(KLogMaxDescriptionLength / 2);
1.759 + event->SetDescription(buf->Des());
1.760 + CleanupStack::PopAndDestroy(); // buf
1.761 +
1.762 + event->SetFlags(0xA);
1.763 +
1.764 + buf8 = TestUtils::CreateBuf8LC(100);
1.765 + event->SetDataL(buf8->Des());
1.766 + TEST(event->Data() == buf8->Des());
1.767 + CleanupStack::PopAndDestroy(); // buf8
1.768 +
1.769 + CLogEvent* event1 = CLogEvent::NewL();
1.770 + CleanupStack::PushL(event1);
1.771 +
1.772 + CLogEvent* event2 = CLogEvent::NewL();
1.773 + CleanupStack::PushL(event2);
1.774 +
1.775 + TEST(TestUtils::EventsEqual(*event1, *event2));
1.776 +
1.777 + finished = EFalse;
1.778 +#ifdef _DEBUG
1.779 + failCount = 0;
1.780 +#endif
1.781 +
1.782 + while(!finished)
1.783 + {
1.784 + __UHEAP_FAILNEXT(failCount++);
1.785 +
1.786 + TRAP(error, event1->CopyL(*event));
1.787 +
1.788 + __UHEAP_RESET;
1.789 +
1.790 + if (error == KErrNone)
1.791 + {
1.792 + TEST(!TestUtils::EventsEqual(*event1, *event2));
1.793 + TEST(TestUtils::EventsEqual(*event1, *event));
1.794 + finished = ETrue;
1.795 + }
1.796 + else
1.797 + {
1.798 + TEST2(error, KErrNoMemory);
1.799 + TEST(TestUtils::EventsEqual(*event1, *event2));
1.800 + TEST(!TestUtils::EventsEqual(*event1, *event));
1.801 + }
1.802 + }
1.803 +
1.804 + CleanupStack::PopAndDestroy(5); // buf8, store, event, event1, event2
1.805 + ::DeleteDataFile(storename);
1.806 + }
1.807 +
1.808 +/**
1.809 +@SYMTestCaseID SYSLIB-LOGENG-CT-1010
1.810 +@SYMTestCaseDesc Tests for CLogEvent::NewL(),CLogEvent::SetDataL() functions
1.811 +@SYMTestPriority High
1.812 +@SYMTestActions Tests for setting event specific data read from the file and try to read the data back from the event.
1.813 + Check for memory errors
1.814 +@SYMTestExpectedResults Test must not fail
1.815 +@SYMREQ REQ0000
1.816 +*/
1.817 +LOCAL_C void TestEventWithFileFailL()
1.818 + {
1.819 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1010 "));
1.820 + CLogEvent* event = CLogEvent::NewL();
1.821 + CleanupStack::PushL(event);
1.822 +
1.823 + // streaming
1.824 + TFileName storename = _L("c:\\T_BASIC_DATA");
1.825 + TUid uid={0x12345678};
1.826 +
1.827 + // create a store
1.828 + theFs.Delete(storename);
1.829 + CDictionaryFileStore* store = CDictionaryFileStore::OpenLC(theFs, storename, uid);
1.830 +
1.831 + RDictionaryWriteStream write;
1.832 + RDictionaryReadStream read;
1.833 +
1.834 + uid.iUid++;
1.835 + write.AssignL(*store, uid);
1.836 + write << KNullDesC8;
1.837 + write.CommitL();
1.838 + write.Close();
1.839 +
1.840 + read.OpenL(*store, uid);
1.841 +
1.842 + TInt failCount = 0;
1.843 + TBool finished = EFalse;
1.844 + TInt error;
1.845 +
1.846 + theFs.SetErrorCondition(KErrGeneral, 0);
1.847 + event->SetDataL(read, 0);
1.848 + theFs.SetErrorCondition(KErrNone, 10000);
1.849 +
1.850 + read.Close();
1.851 + TEST(event->Data() == KNullDesC8);
1.852 +
1.853 + HBufC8* buf8 = TestUtils::CreateBuf8LC(100);
1.854 +
1.855 + uid.iUid++;
1.856 + write.AssignL(*store, uid);
1.857 + write.WriteL(buf8->Des());
1.858 + write.CommitL();
1.859 + write.Close();
1.860 +
1.861 + while(!finished)
1.862 + {
1.863 + read.OpenL(*store, uid);
1.864 + theFs.SetErrorCondition(KErrGeneral, failCount++);
1.865 +
1.866 + TRAP(error, event->SetDataL(read, 100));
1.867 +
1.868 + theFs.SetErrorCondition(KErrGeneral, 10000);
1.869 +
1.870 + read.Close();
1.871 +
1.872 + if (error == KErrNone)
1.873 + {
1.874 + TEST(event->Data() == buf8->Des());
1.875 + finished = ETrue;
1.876 + }
1.877 + else
1.878 + {
1.879 + TEST2(error, KErrGeneral);
1.880 + TEST(event->Data() == KNullDesC8);
1.881 + }
1.882 + }
1.883 +
1.884 + CleanupStack::PopAndDestroy(3); // buf8, store, event
1.885 + ::DeleteDataFile(storename);
1.886 + }
1.887 +
1.888 +void doTestsL()
1.889 + {
1.890 + TestUtils::Initialize(_L("t_logevent"));
1.891 +
1.892 + TheTest.Start(_L("Event"));
1.893 +// TestServerL();
1.894 +
1.895 +
1.896 + TestEventL();
1.897 + theLog.Write(_L8("Test 1 OK\n"));
1.898 +
1.899 + TheTest.Next(_L("Event with heap failure"));
1.900 + TestEventWithHeapFailL();
1.901 + theLog.Write(_L8("Test 2 OK\n"));
1.902 +
1.903 + TheTest.Next(_L("Event with file failure"));
1.904 + TestEventWithFileFailL();
1.905 + theLog.Write(_L8("Test 3 OK\n"));
1.906 + }
1.907 +