1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 #include <test/testexecutelog.h>

    20 #include <caf/content.h>

    21 #include <caf/data.h>

    22 #include <caf/attribute.h>

    23 #include "cafserver.h"

    24 #include "bitset.h"

    25 #include "Consumerstep.h"

    26 #include "attributeset.h"

    27 #include "stringattributeset.h"

    28 #include <caf/virtualpath.h>

    29 #include <e32hal.h>

    30 #include <hal.h>

    31 

    32 using namespace ContentAccess;

    33 

    34 const TInt KCafTestMaxDataTypeLength = 255;

    35 const TInt KCafTestSecToMS = 1000;

    36 

    37 _LIT(KCDataThreadSemaphore, "CData_Thread_Test");

    38 

    39 /* 

    40  * Step1 compares an agent 'size' call with that obtained by RFile

    41  *

    42  */

    43 

    44 CCAFSizeStep::~CCAFSizeStep()

    45 	{

    46 	}

    47 

    48 CCAFSizeStep::CCAFSizeStep(CCAFServer& aParent)

    49 : iParent(aParent)

    50 	{

    51 	SetTestStepName(KCAFSizeStep);

    52 	}

    53 

    54 TVerdict CCAFSizeStep::doTestStepL()

    55 	{

    56 	__UHEAP_MARK;

    57 	

    58 	SetTestStepResult(EInconclusive);

    59 	

    60 	INFO_PRINTF1(_L("Basic Open Content Test"));

    61 	

    62 	TPtrC uri1;

    63 	TPtrC uri2;

    64 	GetStringFromConfig(ConfigSection(),_L("URI1"),uri1);

    65 	GetStringFromConfig(ConfigSection(),_L("URI2"),uri2);

    66 

    67 	INFO_PRINTF2(_L("Creating CContent object with uri: %S"), &uri1);

    68 	CContent* content = CContent::NewLC(uri1);

    69 	INFO_PRINTF1(_L("Creating CData object from content"));

    70 

    71 	CData* data = content->OpenContentL(EPeek);

    72 	CleanupStack::PushL(data);

    73 

    74 	TInt size = 0;

    75 	data->DataSizeL(size);

    76 	INFO_PRINTF2(_L("Size of content from caf CContent::OpenContentL(): %d"),size);

    77 	CleanupStack::PopAndDestroy(data);

    78 	CleanupStack::PopAndDestroy(content);

    79 

    80 	INFO_PRINTF2(_L("Creating CData object with uri: %S"), &uri1);

    81 	TInt size1 = 0;

    82 	

    83 	TBool withoutIntent;

    84 	if (!GetBoolFromConfig(ConfigSection(),_L("WITHOUTINTENT"),withoutIntent))

    85 		{

    86 		INFO_PRINTF1(_L("With Intent"));

    87 		data = CData::NewL(TVirtualPathPtr(uri1), EPeek, EContentShareReadOnly);			

    88 		}

    89 	else

    90 		{

    91 		INFO_PRINTF1(_L("Without Intent"));

    92 		data = CData::NewL(TVirtualPathPtr(uri1), EContentShareReadOnly);

    93 		data->SetProperty(EAgentPropertyAgentUI, 0);

    94 		User::LeaveIfError(data->EvaluateIntent(EPeek));		

    95 		}

    96 	

    97 	CleanupStack::PushL(data);

    98 	data->DataSizeL(size1);

    99 	INFO_PRINTF2(_L("Size of content from caf CData::NewL(): %d"),size1);

   100 	CleanupStack::PopAndDestroy(data);

   101 

   102 	INFO_PRINTF2(_L("Opening standard RFile interface with uri: %S"),&uri2);

   103 	RFile file;

   104 	User::LeaveIfError(file.Open(iParent.Fs(), uri2, EFileRead));

   105 

   106 	TInt size2;

   107 	file.Size(size2);

   108 	file.Close();

   109 

   110 	INFO_PRINTF2(_L("Size of content from f32: %d"),size2);

   111 

   112 	if(size == size2 && size == size1)

   113 		{

   114 		SetTestStepResult(EPass);

   115 		}

   116 	else

   117 		{

   118 		SetTestStepResult(EFail);

   119 		}

   120 	

   121 	__UHEAP_MARKEND;

   122 	return TestStepResult();

   123 	}

   124 

   125 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   126 /* 

   127  * This is the 64bit version of CCAFSizeStep

   128  */

   129 

   130 CCAFSizeStep64::~CCAFSizeStep64()

   131 	{

   132 	}

   133 

   134 CCAFSizeStep64::CCAFSizeStep64(CCAFServer& aParent)

   135 : iParent(aParent)

   136 	{

   137 	SetTestStepName(KCAFSizeStep);

   138 	}

   139 

   140 TVerdict CCAFSizeStep64::doTestStepL()

   141 	{

   142 	__UHEAP_MARK;

   143 	

   144 	SetTestStepResult(EInconclusive);

   145 	

   146 	INFO_PRINTF1(_L("Basic Open Content Test"));

   147 	

   148 	TPtrC uri1;

   149 	TPtrC uri2;

   150 	GetStringFromConfig(ConfigSection(),_L("URI1"),uri1);

   151 	GetStringFromConfig(ConfigSection(),_L("URI2"),uri2);

   152 

   153 	INFO_PRINTF2(_L("Creating CContent object with uri: %S"), &uri1);

   154 	CContent* content = CContent::NewLC(uri1);

   155 	INFO_PRINTF1(_L("Creating CData object from content"));

   156 

   157 	CData* data = content->OpenContentL(EPeek);

   158 	CleanupStack::PushL(data);

   159 

   160 	TInt64 size = 0;

   161 	data->DataSize64L(size);

   162 	INFO_PRINTF2(_L("Size of content from caf CContent::OpenContentL(): %Ld"),size);

   163 	CleanupStack::PopAndDestroy(data);

   164 	CleanupStack::PopAndDestroy(content);

   165 

   166 	INFO_PRINTF2(_L("Creating CData object with uri: %S"), &uri1);

   167 	TInt64 size1 = 0;

   168 	

   169 	TBool withoutIntent;

   170 	if (!GetBoolFromConfig(ConfigSection(),_L("WITHOUTINTENT"),withoutIntent))

   171 		{

   172 		INFO_PRINTF1(_L("With Intent"));

   173 		data = CData::NewL(TVirtualPathPtr(uri1), EPeek, EContentShareReadOnly);			

   174 		}

   175 	else

   176 		{

   177 		INFO_PRINTF1(_L("Without Intent"));

   178 		data = CData::NewL(TVirtualPathPtr(uri1), EContentShareReadOnly);

   179 		data->SetProperty(EAgentPropertyAgentUI, 0);

   180 		User::LeaveIfError(data->EvaluateIntent(EPeek));		

   181 		}

   182 	

   183 	CleanupStack::PushL(data);

   184 	data->DataSize64L(size1);

   185 	INFO_PRINTF2(_L("Size of content from caf CData::NewL(): %Ld"),size1);

   186 	CleanupStack::PopAndDestroy(data);

   187 

   188 	INFO_PRINTF2(_L("Opening standard RFile interface with uri: %S"),&uri2);

   189 	RFile64 file;

   190 	User::LeaveIfError(file.Open(iParent.Fs(), uri2, EFileRead));

   191 

   192 	TInt64 size2;

   193 	file.Size(size2);

   194 	file.Close();

   195 

   196 	INFO_PRINTF2(_L("Size of content from f32: %Ld"),size2);

   197 

   198 	if(size == size2 && size == size1)

   199 		{

   200 		SetTestStepResult(EPass);

   201 		}

   202 	else

   203 		{

   204 		SetTestStepResult(EFail);

   205 		}

   206 	

   207 	__UHEAP_MARKEND;

   208 	return TestStepResult();

   209 	}

   210 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   211 

   212 /*

   213  * This step compares a seek and read using CAF with that using RFile

   214  *

   215  */

   216 

   217 CCAFSeekReadStep::~CCAFSeekReadStep()

   218 	{

   219 	}

   220 

   221 CCAFSeekReadStep::CCAFSeekReadStep(CCAFServer& aParent)

   222 : iParent(aParent)

   223 	{

   224 	SetTestStepName(KCAFSeekReadStep);

   225 	}

   226 

   227 void CCAFSeekReadStep::StandardCheckReturnValue(TInt aReturnValue)

   228 	{

   229 	if (aReturnValue != KErrNone)

   230 		{

   231 		INFO_PRINTF2(_L("ERROR Unexpected return value: %d"),aReturnValue);

   232 		SetTestStepResult(EFail);

   233 		}	

   234 	}

   235 TVerdict CCAFSeekReadStep::doTestStepL()

   236 	{

   237 	SetTestStepResult(EInconclusive);

   238 	

   239 	TBuf8<2> buf1;

   240 	TBuf8<2> buf2;

   241 	TRequestStatus status;

   242 

   243 	__UHEAP_MARK;

   244 	INFO_PRINTF1(_L("Basic Open Content Test"));

   245 	

   246 	TPtrC uri1;

   247 	TPtrC uri2;

   248 	GetStringFromConfig(ConfigSection(),_L("URI1"),uri1);

   249 	GetStringFromConfig(ConfigSection(),_L("URI2"),uri2);

   250 

   251 	INFO_PRINTF2(_L("Creating content object with uri: %S"), &uri1);

   252 	CContent* content = CContent::NewLC(uri1);

   253 

   254 	INFO_PRINTF1(_L("Creating data object from content"));

   255 	CData* data = content->OpenContentL(EPeek);

   256 	

   257 	// don't need CContent any more

   258 	CleanupStack::PopAndDestroy(content);

   259 	CleanupStack::PushL(data);

   260 

   261 	// Now, open the same file using RFile

   262 	RFile file;

   263 	INFO_PRINTF2(_L("Opening standard RFile interface with uri: %S"),&uri2);

   264 	User::LeaveIfError(file.Open(iParent.Fs(), uri2, EFileRead | EFileShareReadersOnly));

   265 	CleanupClosePushL(file);

   266 

   267 	TInt size = 0;

   268 	file.Size(size);

   269 	INFO_PRINTF2(_L("Size of content from f32: %d"),size);

   270 	

   271 	// Seek and read from start using both CAF and RFile

   272 	TInt pos1 = size/4;

   273 	data->Seek(ESeekStart, pos1);

   274 	TInt pos2 = size/4;

   275 	file.Seek(ESeekStart, pos2);

   276 	data->Read(buf1);

   277 	file.Read(buf2);

   278 	INFO_PRINTF2(_L("Position from ESeekStart test using CData: %d"), pos1);

   279 	INFO_PRINTF2(_L("Position from ESeekStart test using RFile: %d"), pos2);

   280 	if (buf1 != buf2 || pos1 != pos2 || pos1 != size/4)

   281 		{

   282 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   283 		SetTestStepResult(EFail);

   284 		}

   285 

   286 	// set the location within the file then retrieve the current location within the file

   287 	pos1=0;

   288 	pos2=0;

   289 	data->Seek(ESeekCurrent, pos1);

   290 	file.Seek(ESeekCurrent, pos2);

   291 

   292 	INFO_PRINTF2(_L("Current position using CData: %d"), pos1);

   293 	INFO_PRINTF2(_L("Current position using RFile: %d"), pos2);

   294 

   295 	if(pos1 != pos2 || pos1 != (size/4 + buf1.Length()))

   296 		{

   297 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   298 		SetTestStepResult(EFail);

   299 		}

   300 

   301 	// Seek and read from current using both CAF and RFile

   302 	pos1 = size/4;

   303 	data->Seek(ESeekCurrent, pos1);

   304 	pos2 = size/4;

   305 	file.Seek(ESeekCurrent, pos2);

   306 	data->Read(buf1);

   307 	file.Read(buf2);

   308 	INFO_PRINTF2(_L("Position from ESeekCurrent test using CData: %d"), pos1);

   309 	INFO_PRINTF2(_L("Position from ESeekCurrent test using RFile: %d"), pos2);

   310 	if (buf1 != buf2 || pos1 != pos2 || pos1 != (size/2 + buf1.Length()))

   311 		{

   312 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   313 		SetTestStepResult(EFail);

   314 		}

   315 

   316 	// Seek and read from end using both CAF and RFile

   317 	pos1 = -size/4;

   318 	data->Seek(ESeekEnd, pos1);

   319 	pos2 = -size/4;

   320 	file.Seek(ESeekEnd, pos2);

   321 	data->Read(buf1);

   322 	file.Read(buf2);

   323 	INFO_PRINTF2(_L("Position from ESeekEnd test using CData: %d"), pos1);

   324 	INFO_PRINTF2(_L("Position from ESeekEnd test using RFile: %d"), pos2);

   325 	if (buf1 != buf2 || pos1 != pos2 || pos1 != (size - size/4))

   326 		{

   327 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   328 		SetTestStepResult(EFail);

   329 		}

   330 

   331 	// Test other overloaded forms of CData::Read

   332 

   333 	// Read only 1 byte using both CAF and RFile

   334 	pos1 = size/4;

   335 	data->Seek(ESeekStart, pos1);

   336 	pos2 = size/4;

   337 	file.Seek(ESeekStart, pos2);

   338 	data->Read(buf1,1);

   339 	file.Read(buf2,1);

   340 	INFO_PRINTF2(_L("Data Length from  CData::Read(TDesC& ,TInt Length) : %d"), buf1.Length());

   341 	INFO_PRINTF2(_L("Data Length from  RFile::Read(TDesC& , TInt Length): %d"), buf2.Length());

   342 	

   343 	pos1=0;

   344 	pos2=0;

   345 	data->Seek(ESeekCurrent, pos1);

   346 	file.Seek(ESeekCurrent,pos2);

   347 	if (buf1 != buf2 || pos1 != pos2 || buf1.Length() != buf2.Length())

   348 		{

   349 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   350 		SetTestStepResult(EFail);

   351 		}

   352 

   353 	// Read asynchronously using both CAF and RFile

   354 	INFO_PRINTF1(_L("Asynchronous read from CAF and RFile"));

   355 	pos1 = size/4;

   356 	data->Seek(ESeekStart, pos1);

   357 	pos2 = size/4;

   358 	file.Seek(ESeekStart, pos2);

   359 	status = KRequestPending;

   360 	data->Read(buf1,status);

   361 	User::WaitForRequest(status);

   362 	status = KRequestPending;

   363 	file.Read(buf2,status);

   364 	User::WaitForRequest(status);

   365 	INFO_PRINTF2(_L("Data length from  CData::Read(TDesC& ,TRequestStatus& aStatus): %d"), buf1.Length());

   366 	INFO_PRINTF2(_L("Data length from  RFile::Read(TDesC& , TRequestStatus& aStatus): %d"), buf2.Length());

   367 

   368 	pos1=0;

   369 	pos2=0;

   370 	data->Seek(ESeekCurrent, pos1);

   371 	file.Seek(ESeekCurrent,pos2);

   372 	if (buf1 != buf2 || pos1 != pos2 || buf1.Length() != buf2.Length())

   373 		{

   374 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   375 		SetTestStepResult(EFail);

   376 		}

   377 

   378 	// Read only 1 byte asynchronously using both CAF and RFile

   379 	INFO_PRINTF1(_L("Asynchronous read of 1 byte from CAF and RFile"));

   380 	pos1 = size/4;

   381 	data->Seek(ESeekStart, pos1);

   382 	pos2 = size/4;

   383 	file.Seek(ESeekStart, pos2);

   384 	status = KRequestPending;

   385 	data->Read(buf1,1,status);

   386 	User::WaitForRequest(status);

   387 	status = KRequestPending;

   388 	file.Read(buf2,1, status);

   389 	User::WaitForRequest(status);

   390 	INFO_PRINTF2(_L("Data Length from CData::Read(TDesC& ,TInt Length, TRequestStatus aStatus) : %d"), buf1.Length());

   391 	INFO_PRINTF2(_L("Data Length from RFile::Read(TDesC& , TInt Length, TRequestStatus aStatus): %d"), buf2.Length());

   392 

   393 	pos1=0;

   394 	pos2=0;

   395 	data->Seek(ESeekCurrent, pos1);

   396 	file.Seek(ESeekCurrent,pos2);

   397 	if (buf1 != buf2 || pos1 != pos2 || buf1.Length() != buf2.Length())

   398 		{

   399 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   400 		SetTestStepResult(EFail);

   401 		}

   402 

   403 	// read past EOF

   404 	pos1 = size+1;

   405 	pos2 = size+1;

   406 	data->Seek(ESeekStart, pos1);

   407 	file.Seek(ESeekStart, pos2);

   408 	data->Read(buf1);

   409 	file.Read(buf2);

   410 

   411 	if(buf1.Length() != 0 || buf1.Length() != 0)

   412 		{

   413 		INFO_PRINTF1(_L("ERROR data read past EOF"));

   414 		SetTestStepResult(EFail);

   415 		}

   416 

   417 	

   418 	// Read asynchronously supplying an offset using both CAF and RFile

   419 	TInt err;

   420 	INFO_PRINTF1(_L("Asynchronous read of 1 byte from CAF and RFile supplying an offset within the file"));

   421 	pos1 = size/4;

   422 	pos2 = size/4;

   423 	status = KRequestPending;

   424 	err = data->Read(pos1,buf1,1,status);

   425 	

   426 	StandardCheckReturnValue(err);

   427 	

   428 	User::WaitForRequest(status);

   429 	status = KRequestPending;

   430 	file.Read(pos2, buf2,1, status);

   431 	User::WaitForRequest(status);

   432 	INFO_PRINTF2(_L("Data Length from CData::Read(TInt aPos, TDesC& , TInt Length, TRequestStatus aStatus) : %d"), buf1.Length());

   433 	INFO_PRINTF2(_L("Data Length from RFile::Read(TInt aPos, TDesC& , TInt Length, TRequestStatus aStatus): %d"), buf2.Length());

   434 

   435 	pos1=0;

   436 	pos2=0;

   437 	data->Seek(ESeekCurrent, pos1);

   438 	file.Seek(ESeekCurrent,pos2);

   439 	if (buf1 !=buf2 || pos1 != pos2 || buf1.Length() != buf2.Length())

   440 		{

   441 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   442 		SetTestStepResult(EFail);

   443 		}

   444 		

   445 	// Check asynchronous cancellation

   446 	err = 0;

   447 	INFO_PRINTF1(_L("Asynchronous read cancellation using both CAF and RFile with an offset within the file"));	

   448 	pos1 = size/4;

   449 	pos2 = size/4;

   450 	status = KRequestPending;

   451 	err = data->Read(pos1,buf1,1,status);

   452 	StandardCheckReturnValue(err);

   453 	data->ReadCancel(status);

   454 	User::WaitForRequest(status);

   455 	TRequestStatus status2(KRequestPending);

   456 	file.Read(pos2, buf2,1, status2);	

   457 	file.ReadCancel();

   458 	User::WaitForRequest(status2);	

   459 	INFO_PRINTF3(_L("Data Length from CData::Read(TInt aPos, TDesC& , TInt Length, TRequestStatus aStatus) : %d, status is %d"), buf1.Length(), status.Int());

   460 	INFO_PRINTF3(_L("Data Length from RFile::Read(TInt aPos, TDesC& , TInt Length, TRequestStatus aStatus): %d, status is %d"), buf2.Length(), status2.Int());	

   461 	if (status.Int() != status2.Int() || buf1 !=buf2 || pos1 != pos2 || buf1.Length() != buf2.Length())

   462 		{

   463 		INFO_PRINTF1(_L("ERROR status, buffers or position do not match"));

   464 		SetTestStepResult(EFail);

   465 		}

   466 		

   467 	// read past EOF

   468 	pos1 = size+1;

   469 	pos2 = size+1;

   470 	status = KRequestPending;

   471 	data->Read(pos1,buf1,1,status);

   472 	StandardCheckReturnValue(err);

   473 	User::WaitForRequest(status);

   474 	status = KRequestPending;

   475 	file.Read(pos2,buf2,1,status);

   476 	User::WaitForRequest(status);

   477 	

   478 	if(buf1.Length() != 0 || buf1.Length() != 0)

   479 		{

   480 		INFO_PRINTF1(_L("ERROR data read past EOF"));

   481 		SetTestStepResult(EFail);

   482 		}

   483 		

   484 	// read over the length of the buffer

   485 	INFO_PRINTF1(_L("Asynchronous read of 5 bytes from CAF and RFile supplying an offset within the file"));

   486 	pos1 = size/4;

   487 	pos2 = size/4;

   488 	status = KRequestPending;

   489 	err = data->Read(pos1,buf1,5,status);

   490 	StandardCheckReturnValue(err);

   491 	User::WaitForRequest(status);

   492 	if(status.Int()!=KErrOverflow)

   493 		{

   494 		INFO_PRINTF2(_L("ERROR Unexpected status returned: %d"),status.Int());

   495 		SetTestStepResult(EFail);

   496 		}

   497 	status = KRequestPending;

   498 	file.Read(pos2, buf2,5, status);

   499 	User::WaitForRequest(status);

   500 	INFO_PRINTF2(_L("Data Length from CData::Read(TInt aPos, TDesC& , TInt Length, TRequestStatus aStatus) : %d"), buf1.Length());

   501 	INFO_PRINTF2(_L("Data Length from RFile::Read(TInt aPos, TDesC& , TInt Length, TRequestStatus aStatus): %d"), buf2.Length());

   502 

   503 	if (buf1 !=buf2 ||  buf1.Length() != buf2.Length())

   504 		{

   505 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   506 		SetTestStepResult(EFail);

   507 		}

   508 	// read negative position this should return KErrArgument, dont supply -ve pos to RFile as will panic test

   509 	INFO_PRINTF1(_L("Asynchronous read from CAF supplying a negative offset within the file"));

   510 	pos1 = -1;

   511 	status = KRequestPending;

   512 	err = data->Read(pos1,buf1,5,status);

   513 	if(err!=KErrArgument)

   514 		{

   515 		INFO_PRINTF2(_L("ERROR Unexpected return value: %d"),err);

   516 		SetTestStepResult(EFail);

   517 		}

   518 		

   519 	// Read asynchronously supplying an offset of 0 and a length greater than size of file using both CAF and RFile

   520 	INFO_PRINTF1(_L("Asynchronous read of length greater than size of file from CAF and RFile supplying an offset of 0 within the file"));

   521 	TBuf8<256> buf3;

   522 	TBuf8<256> buf4;

   523 	pos1 = 0;

   524 	pos2 = 0;

   525 	status = KRequestPending;

   526 	err = data->Read(pos1,buf3,size+1,status);

   527 	StandardCheckReturnValue(err);

   528 	User::WaitForRequest(status);

   529 	status = KRequestPending;

   530 	file.Read(pos2, buf4,size+1, status);

   531 	User::WaitForRequest(status);

   532 	INFO_PRINTF2(_L("Data Length from CData::Read(TInt aPos, TDesC& , TInt Length, TRequestStatus aStatus) : %d"), buf3.Size());

   533 	INFO_PRINTF2(_L("Data Length from RFile::Read(TInt aPos, TDesC& , TInt Length, TRequestStatus aStatus): %d"), buf4.Size());

   534 

   535 	pos1=0;

   536 	pos2=0;

   537 	data->Seek(ESeekCurrent, pos1);

   538 	file.Seek(ESeekCurrent,pos2);

   539 	if (buf3 != buf4 || pos1 != pos2 || buf3.Length() != buf4.Length() || pos1 != size || 

   540 									pos2 != size || buf3.Size() != pos1 || buf4.Size() != pos2)

   541 		{

   542 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   543 		SetTestStepResult(EFail);

   544 		}

   545 

   546 	// Read asynchronously supplying an offset of size/4 and a length greater than size of file using both CAF and RFile

   547 	INFO_PRINTF1(_L("Asynchronous read of length greater than size of file from CAF and RFile supplying an offset within the file"));

   548 	pos1 = size/4;

   549 	pos2 = size/4;

   550 	status = KRequestPending;

   551 	err = data->Read(pos1,buf3,size+1,status);

   552 	StandardCheckReturnValue(err);

   553 	User::WaitForRequest(status);

   554 	status = KRequestPending;

   555 	file.Read(pos2, buf4,size+1, status);

   556 	User::WaitForRequest(status);

   557 	INFO_PRINTF2(_L("Data Length from CData::Read(TInt aPos, TDesC& , TInt Length, TRequestStatus aStatus) : %d"), buf3.Size());

   558 	INFO_PRINTF2(_L("Data Length from RFile::Read(TInt aPos, TDesC& , TInt Length, TRequestStatus aStatus): %d"), buf4.Size());

   559 

   560 	pos1=0;

   561 	pos2=0;

   562 	data->Seek(ESeekCurrent, pos1);

   563 	file.Seek(ESeekCurrent,pos2);

   564 	if (buf3 != buf4 || pos1 != pos2 || buf3.Size() != buf4.Size() || pos1 != size || pos2 != size)

   565 		{

   566 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   567 		SetTestStepResult(EFail);

   568 		}	

   569 		

   570 	CleanupStack::PopAndDestroy(2, data);

   571 

   572 	__UHEAP_MARKEND;

   573 

   574 	if (TestStepResult() != EFail)

   575 		{

   576 		SetTestStepResult(EPass);

   577 		}

   578 

   579 	return TestStepResult();

   580 	}

   581 

   582 

   583 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   584 /*

   585  * This is the 64bit version of CCAFSeekReadStep. 

   586 */

   587 

   588 CCAFSeekReadStep64::~CCAFSeekReadStep64()

   589 	{

   590 	}

   591 

   592 CCAFSeekReadStep64::CCAFSeekReadStep64(CCAFServer& aParent)

   593 : iParent(aParent)

   594 	{

   595 	SetTestStepName(KCAFSeekReadStep);

   596 	}

   597 

   598 void CCAFSeekReadStep64::StandardCheckReturnValue(TInt aReturnValue)

   599 	{

   600 	if (aReturnValue != KErrNone)

   601 		{

   602 		INFO_PRINTF2(_L("ERROR Unexpected return value: %d"),aReturnValue);

   603 		SetTestStepResult(EFail);

   604 		}	

   605 	}

   606 TVerdict CCAFSeekReadStep64::doTestStepL()

   607 	{

   608 	SetTestStepResult(EInconclusive);

   609 	

   610 	TBuf8<2> buf1;

   611 	TBuf8<2> buf2;

   612 	TRequestStatus status;

   613 

   614 	__UHEAP_MARK;

   615 	INFO_PRINTF1(_L("Basic Open Content Test"));

   616 	

   617 	TPtrC uri1;

   618 	TPtrC uri2;

   619 	GetStringFromConfig(ConfigSection(),_L("URI1"),uri1);

   620 	GetStringFromConfig(ConfigSection(),_L("URI2"),uri2);

   621 

   622 	INFO_PRINTF2(_L("Creating content object with uri: %S"), &uri1);

   623 	CContent* content = CContent::NewLC(uri1);

   624 

   625 	INFO_PRINTF1(_L("Creating data object from content"));

   626 	CData* data = content->OpenContentL(EPeek);

   627 	

   628 	// don't need CContent any more

   629 	CleanupStack::PopAndDestroy(content);

   630 	CleanupStack::PushL(data);

   631 

   632 	// Now, open the same file using RFile

   633 	RFile64 file;

   634 	INFO_PRINTF2(_L("Opening standard RFile interface with uri: %S"),&uri2);

   635 	User::LeaveIfError(file.Open(iParent.Fs(), uri2, EFileRead | EFileShareReadersOnly));

   636 	CleanupClosePushL(file);

   637 

   638 	TInt64 size = 0;

   639 	file.Size(size);

   640 	INFO_PRINTF2(_L("Size of content from f32: %Ld"),size);

   641 	

   642 	// Seek and read from start using both CAF and RFile

   643 	TInt64 pos1 = size/4;

   644 	data->Seek64(ESeekStart, pos1);

   645 	//pos2 needs to be modified to TInt64 when file server supports 64bit

   646 	TInt64 pos2 = size/4;

   647 	file.Seek(ESeekStart, pos2);

   648 	data->Read(buf1);

   649 	file.Read(buf2);

   650 	INFO_PRINTF2(_L("Position from ESeekStart test using CData: %Ld"), pos1);

   651 	INFO_PRINTF2(_L("Position from ESeekStart test using RFile: %Ld"), pos2);

   652 	if (buf1 != buf2 || pos1 != pos2 || pos1 != size/4)

   653 		{

   654 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   655 		SetTestStepResult(EFail);

   656 		}

   657 

   658 	// set the location within the file then retrieve the current location within the file

   659 	pos1=0;

   660 	pos2=0;

   661 	data->Seek64(ESeekCurrent, pos1);

   662 	file.Seek(ESeekCurrent, pos2);

   663 

   664 	INFO_PRINTF2(_L("Current position using CData: %Ld"), pos1);

   665 	INFO_PRINTF2(_L("Current position using RFile: %Ld"), pos2);

   666 

   667 	if(pos1 != pos2 || pos1 != (size/4 + buf1.Length()))

   668 		{

   669 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   670 		SetTestStepResult(EFail);

   671 		}

   672 

   673 	// Seek and read from current using both CAF and RFile

   674 	pos1 = size/4;

   675 	data->Seek64(ESeekCurrent, pos1);

   676 	pos2 = size/4;

   677 	file.Seek(ESeekCurrent, pos2);

   678 	data->Read(buf1);

   679 	file.Read(buf2);

   680 	INFO_PRINTF2(_L("Position from ESeekCurrent test using CData: %Ld"), pos1);

   681 	INFO_PRINTF2(_L("Position from ESeekCurrent test using RFile: %Ld"), pos2);

   682 	if (buf1 != buf2 || pos1 != pos2 || pos1 != (size/2 + buf1.Length()))

   683 		{

   684 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   685 		SetTestStepResult(EFail);

   686 		}

   687 

   688 	// Seek and read from end using both CAF and RFile

   689 	pos1 = -size/4;

   690 	data->Seek64(ESeekEnd, pos1);

   691 	pos2 = -size/4;

   692 	file.Seek(ESeekEnd, pos2);

   693 	data->Read(buf1);

   694 	file.Read(buf2);

   695 	INFO_PRINTF2(_L("Position from ESeekEnd test using CData: %Ld"), pos1);

   696 	INFO_PRINTF2(_L("Position from ESeekEnd test using RFile: %Ld"), pos2);

   697 	if (buf1 != buf2 || pos1 != pos2 || pos1 != (size - size/4))

   698 		{

   699 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   700 		SetTestStepResult(EFail);

   701 		}

   702 

   703 	// Test other overloaded forms of CData::Read

   704 

   705 	// Read only 1 byte using both CAF and RFile

   706 	pos1 = size/4;

   707 	data->Seek64(ESeekStart, pos1);

   708 	pos2 = size/4;

   709 	file.Seek(ESeekStart, pos2);

   710 	data->Read(buf1,1);

   711 	file.Read(buf2,1);

   712 	INFO_PRINTF2(_L("Data Length from  CData::Read(TDesC& ,TInt Length) : %d"), buf1.Length());

   713 	INFO_PRINTF2(_L("Data Length from  RFile::Read(TDesC& , TInt Length): %d"), buf2.Length());

   714 	

   715 	pos1=0;

   716 	pos2=0;

   717 	data->Seek64(ESeekCurrent, pos1);

   718 	file.Seek(ESeekCurrent,pos2);

   719 	if (buf1 != buf2 || pos1 != pos2 || buf1.Length() != buf2.Length())

   720 		{

   721 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   722 		SetTestStepResult(EFail);

   723 		}

   724 

   725 	// Read asynchronously using both CAF and RFile

   726 	INFO_PRINTF1(_L("Asynchronous read from CAF and RFile"));

   727 	pos1 = size/4;

   728 	data->Seek64(ESeekStart, pos1);

   729 	pos2 = size/4;

   730 	file.Seek(ESeekStart, pos2);

   731 	status = KRequestPending;

   732 	data->Read(buf1,status);

   733 	User::WaitForRequest(status);

   734 	status = KRequestPending;

   735 	file.Read(buf2,status);

   736 	User::WaitForRequest(status);

   737 	INFO_PRINTF2(_L("Data length from  CData::Read(TDesC& ,TRequestStatus& aStatus): %d"), buf1.Length());

   738 	INFO_PRINTF2(_L("Data length from  RFile::Read(TDesC& , TRequestStatus& aStatus): %d"), buf2.Length());

   739 

   740 	pos1=0;

   741 	pos2=0;

   742 	data->Seek64(ESeekCurrent, pos1);

   743 	file.Seek(ESeekCurrent,pos2);

   744 	if (buf1 != buf2 || pos1 != pos2 || buf1.Length() != buf2.Length())

   745 		{

   746 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   747 		SetTestStepResult(EFail);

   748 		}

   749 

   750 	// Read only 1 byte asynchronously using both CAF and RFile

   751 	INFO_PRINTF1(_L("Asynchronous read of 1 byte from CAF and RFile"));

   752 	pos1 = size/4;

   753 	data->Seek64(ESeekStart, pos1);

   754 	pos2 = size/4;

   755 	file.Seek(ESeekStart, pos2);

   756 	status = KRequestPending;

   757 	data->Read(buf1,1,status);

   758 	User::WaitForRequest(status);

   759 	status = KRequestPending;

   760 	file.Read(buf2,1, status);

   761 	User::WaitForRequest(status);

   762 	INFO_PRINTF2(_L("Data Length from CData::Read(TDesC& ,TInt Length, TRequestStatus aStatus) : %d"), buf1.Length());

   763 	INFO_PRINTF2(_L("Data Length from RFile::Read(TDesC& , TInt Length, TRequestStatus aStatus): %d"), buf2.Length());

   764 

   765 	pos1=0;

   766 	pos2=0;

   767 	data->Seek64(ESeekCurrent, pos1);

   768 	file.Seek(ESeekCurrent,pos2);

   769 	if (buf1 != buf2 || pos1 != pos2 || buf1.Length() != buf2.Length())

   770 		{

   771 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   772 		SetTestStepResult(EFail);

   773 		}

   774 

   775 	// read past EOF

   776 	pos1 = size+1;

   777 	pos2 = size+1;

   778 	data->Seek64(ESeekStart, pos1);

   779 	file.Seek(ESeekStart, pos2);

   780 	data->Read(buf1);

   781 	file.Read(buf2);

   782 

   783 	if(buf1.Length() != 0 || buf1.Length() != 0)

   784 		{

   785 		INFO_PRINTF1(_L("ERROR data read past EOF"));

   786 		SetTestStepResult(EFail);

   787 		}

   788 

   789 	

   790 	// Read asynchronously supplying an offset using both CAF and RFile

   791 	TInt err;

   792 	INFO_PRINTF1(_L("Asynchronous read of 1 byte from CAF and RFile supplying an offset within the file"));

   793 	pos1 = size/4;

   794 	pos2 = size/4;

   795 	status = KRequestPending;

   796 	err = data->Read(pos1,buf1,1,status);

   797 	

   798 	StandardCheckReturnValue(err);

   799 	

   800 	User::WaitForRequest(status);

   801 	status = KRequestPending;

   802 	file.Read(pos2, buf2,1, status);

   803 	User::WaitForRequest(status);

   804 	INFO_PRINTF2(_L("Data Length from CData::Read(TInt64 aPos, TDesC& , TInt Length, TRequestStatus aStatus) : %d"), buf1.Length());

   805 	INFO_PRINTF2(_L("Data Length from RFile::Read(TInt64 aPos, TDesC& , TInt Length, TRequestStatus aStatus): %d"), buf2.Length());

   806 

   807 	pos1=0;

   808 	pos2=0;

   809 	data->Seek64(ESeekCurrent, pos1);

   810 	file.Seek(ESeekCurrent,pos2);

   811 	if (buf1 !=buf2 || pos1 != pos2 || buf1.Length() != buf2.Length())

   812 		{

   813 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   814 		SetTestStepResult(EFail);

   815 		}

   816 		

   817 	// Check asynchronous cancellation

   818 	err = 0;

   819 	INFO_PRINTF1(_L("Asynchronous read cancellation using both CAF and RFile with an offset within the file"));	

   820 	pos1 = size/4;

   821 	pos2 = size/4;

   822 	status = KRequestPending;

   823 	err = data->Read(pos1,buf1,1,status);

   824 	StandardCheckReturnValue(err);

   825 	data->ReadCancel(status);

   826 	User::WaitForRequest(status);

   827 	TRequestStatus status2(KRequestPending);

   828 	file.Read(pos2, buf2,1, status2);	

   829 	file.ReadCancel();

   830 	User::WaitForRequest(status2);	

   831 	INFO_PRINTF3(_L("Data Length from CData::Read(TInt64 aPos, TDesC& , TInt Length, TRequestStatus aStatus) : %d, status is %d"), buf1.Length(), status.Int());

   832 	INFO_PRINTF3(_L("Data Length from RFile::Read(TInt64 aPos, TDesC& , TInt Length, TRequestStatus aStatus): %d, status is %d"), buf2.Length(), status2.Int());	

   833 	if (status.Int() != status2.Int() || buf1 !=buf2 || pos1 != pos2 || buf1.Length() != buf2.Length())

   834 		{

   835 		INFO_PRINTF1(_L("ERROR status, buffers or position do not match"));

   836 		SetTestStepResult(EFail);

   837 		}

   838 		

   839 	// read past EOF

   840 	pos1 = size+1;

   841 	pos2 = size+1;

   842 	status = KRequestPending;

   843 	data->Read(pos1,buf1,1,status);

   844 	StandardCheckReturnValue(err);

   845 	User::WaitForRequest(status);

   846 	status = KRequestPending;

   847 	file.Read(pos2,buf2,1,status);

   848 	User::WaitForRequest(status);

   849 	

   850 	if(buf1.Length() != 0 || buf1.Length() != 0)

   851 		{

   852 		INFO_PRINTF1(_L("ERROR data read past EOF"));

   853 		SetTestStepResult(EFail);

   854 		}

   855 		

   856 	// read over the length of the buffer

   857 	INFO_PRINTF1(_L("Asynchronous read of 5 bytes from CAF and RFile supplying an offset within the file"));

   858 	pos1 = size/4;

   859 	pos2 = size/4;

   860 	status = KRequestPending;

   861 	err = data->Read(pos1,buf1,5,status);

   862 	StandardCheckReturnValue(err);

   863 	User::WaitForRequest(status);

   864 	if(status.Int()!=KErrOverflow)

   865 		{

   866 		INFO_PRINTF2(_L("ERROR Unexpected status returned: %d"),status.Int());

   867 		SetTestStepResult(EFail);

   868 		}

   869 	status = KRequestPending;

   870 	file.Read(pos2, buf2,5, status);

   871 	User::WaitForRequest(status);

   872 	INFO_PRINTF2(_L("Data Length from CData::Read(TInt64 aPos, TDesC& , TInt Length, TRequestStatus aStatus) : %d"), buf1.Length());

   873 	INFO_PRINTF2(_L("Data Length from RFile::Read(TInt64 aPos, TDesC& , TInt Length, TRequestStatus aStatus): %d"), buf2.Length());

   874 

   875 	if (buf1 !=buf2 ||  buf1.Length() != buf2.Length())

   876 		{

   877 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   878 		SetTestStepResult(EFail);

   879 		}

   880 	// read negative position this should return KErrArgument, dont supply -ve pos to RFile as will panic test

   881 	INFO_PRINTF1(_L("Asynchronous read from CAF supplying a negative offset within the file"));

   882 	pos1 = -1;

   883 	status = KRequestPending;

   884 	err = data->Read(pos1,buf1,5,status);

   885 	if(err!=KErrArgument)

   886 		{

   887 		INFO_PRINTF2(_L("ERROR Unexpected return value: %d"),err);

   888 		SetTestStepResult(EFail);

   889 		}

   890 		

   891 	// Read asynchronously supplying an offset of 0 and a length greater than size of file using both CAF and RFile

   892 	INFO_PRINTF1(_L("Asynchronous read of length greater than size of file from CAF and RFile supplying an offset of 0 within the file"));

   893 	TBuf8<256> buf3;

   894 	TBuf8<256> buf4;

   895 	pos1 = 0;

   896 	pos2 = 0;

   897 	status = KRequestPending;

   898 	err = data->Read(pos1,buf3,size+1,status);

   899 	StandardCheckReturnValue(err);

   900 	User::WaitForRequest(status);

   901 	status = KRequestPending;

   902 	file.Read(pos2, buf4,size+1, status);

   903 	User::WaitForRequest(status);

   904 	INFO_PRINTF2(_L("Data Length from CData::Read(TInt64 aPos, TDesC& , TInt Length, TRequestStatus aStatus) : %d"), buf3.Size());

   905 	INFO_PRINTF2(_L("Data Length from RFile::Read(TInt64 aPos, TDesC& , TInt Length, TRequestStatus aStatus): %d"), buf4.Size());

   906 

   907 	pos1=0;

   908 	pos2=0;

   909 	data->Seek64(ESeekCurrent, pos1);

   910 	file.Seek(ESeekCurrent,pos2);

   911 	if (buf3 != buf4 || pos1 != pos2 || buf3.Length() != buf4.Length() || pos1 != size || 

   912 									pos2 != size || buf3.Size() != pos1 || buf4.Size() != pos2)

   913 		{

   914 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   915 		SetTestStepResult(EFail);

   916 		}

   917 

   918 	// Read asynchronously supplying an offset of size/4 and a length greater than size of file using both CAF and RFile

   919 	INFO_PRINTF1(_L("Asynchronous read of length greater than size of file from CAF and RFile supplying an offset within the file"));

   920 	pos1 = size/4;

   921 	pos2 = size/4;

   922 	status = KRequestPending;

   923 	err = data->Read(pos1,buf3,size+1,status);

   924 	StandardCheckReturnValue(err);

   925 	User::WaitForRequest(status);

   926 	status = KRequestPending;

   927 	file.Read(pos2, buf4,size+1, status);

   928 	User::WaitForRequest(status);

   929 	INFO_PRINTF2(_L("Data Length from CData::Read(TInt64 aPos, TDesC& , TInt Length, TRequestStatus aStatus) : %d"), buf3.Size());

   930 	INFO_PRINTF2(_L("Data Length from RFile::Read(TInt64 aPos, TDesC& , TInt Length, TRequestStatus aStatus): %d"), buf4.Size());

   931 

   932 	pos1=0;

   933 	pos2=0;

   934 	data->Seek64(ESeekCurrent, pos1);

   935 	file.Seek(ESeekCurrent,pos2);

   936 	if (buf3 != buf4 || pos1 != pos2 || buf3.Size() != buf4.Size() || pos1 != size || pos2 != size)

   937 		{

   938 		INFO_PRINTF1(_L("ERROR buffers or position do not match"));

   939 		SetTestStepResult(EFail);

   940 		}	

   941 	

   942 	CleanupStack::PopAndDestroy(2, data);

   943 	

   944 	__UHEAP_MARKEND;

   945 	

   946 	if (TestStepResult() != EFail)

   947 		{

   948 		SetTestStepResult(EPass);

   949 		}

   950 

   951 	return TestStepResult();

   952 	}

   953 

   954 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   955 /*

   956  * This step retrieves the attributes of a file using the CAF framework

   957  *

   958  */

   959 

   960 CCAFAttributesStep::~CCAFAttributesStep()

   961 	{

   962 	}

   963 

   964 CCAFAttributesStep::CCAFAttributesStep(CCAFServer& aParent) : iParent(aParent)

   965 	{

   966 	SetTestStepName(KCAFAttributesStep);

   967 	}

   968 

   969 

   970 TVerdict CCAFAttributesStep::doTestStepL()

   971 	{

   972 	CContent *content;

   973 	CAttribute *attrs; 

   974 	TPtrC fileName;

   975 	TBool Protected;

   976 	TBool Forwardable;

   977 	

   978 	

   979 	TBool Value;

   980 

   981 	SetTestStepResult(EFail);

   982 

   983 	GetStringFromConfig(ConfigSection(),_L("filename"),fileName);

   984 	GetBoolFromConfig(ConfigSection(),_L("Protected"),Protected);

   985 	GetBoolFromConfig(ConfigSection(),_L("Forwardable"),Forwardable);

   986 

   987 

   988 	INFO_PRINTF2(_L("Check attributes of file: %S"), &fileName);	

   989 

   990 	__UHEAP_MARK;

   991 

   992 	// Open a file and retrieve the attributes

   993 	content = CContent::NewLC(fileName);

   994 	attrs = content->NewAttributeL(ETrue);

   995 	CleanupStack::PushL(attrs);

   996 

   997 	// Assume all the attributes are what we expect them to be

   998 	SetTestStepResult(EPass);

   999 

  1000 	Value = attrs->ResponseSet().IsSet(EIsProtected);

  1001 	if(Value != Protected)

  1002 		{

  1003 		SetTestStepResult(EFail);

  1004 		Protected ? INFO_PRINTF1(_L("File is Protected")) : INFO_PRINTF1(_L("File is not Protected"));

  1005 		}

  1006 

  1007 	Value = attrs->ResponseSet().IsSet(EIsForwardable);

  1008 	if(Value != Forwardable)

  1009 		{

  1010 		SetTestStepResult(EFail);

  1011 		Forwardable ? INFO_PRINTF1(_L("File is Forwardable")) : INFO_PRINTF1(_L("File is not Forwardable"));

  1012 		}

  1013 

  1014 	CleanupStack::PopAndDestroy(2, content); 

  1015 

  1016 	__UHEAP_MARKEND;

  1017 	return TestStepResult();

  1018 	}

  1019 

  1020 

  1021 /*

  1022  * This step retrieves the string attributes of a file using the CAF framework

  1023  *

  1024  */

  1025 

  1026 CCAFStringAttributesStep::~CCAFStringAttributesStep()

  1027 	{

  1028 	}

  1029 

  1030 CCAFStringAttributesStep::CCAFStringAttributesStep(CCAFServer& aParent) : iParent(aParent)

  1031 	{

  1032 	SetTestStepName(KCAFStringAttributesStep);

  1033 	}

  1034 

  1035 

  1036 TVerdict CCAFStringAttributesStep::doTestStepL()

  1037 	{

  1038 	TInt expectedResult;

  1039 	TInt attribute;

  1040 	TPtrC expectedValue;

  1041 	TBuf <256> value; //this will be used to test KErrOverFlow when transactionid is 257char long.

  1042 	TInt result = KErrNone;

  1043 	TPtrC uri;

  1044 	TPtrC uniqueId;

  1045 

  1046 	SetTestStepResult(EPass);

  1047 

  1048 	GetIntFromConfig(ConfigSection(),_L("stringattribute"),attribute);

  1049 	GetStringFromConfig(ConfigSection(),_L("uri"),uri);

  1050 	GetStringFromConfig(ConfigSection(),_L("uniqueid"),uniqueId);

  1051 	GetStringFromConfig(ConfigSection(),_L("value"),expectedValue);

  1052 	GetIntFromConfig(ConfigSection(),_L("result"),expectedResult);

  1053 

  1054 	__UHEAP_MARK;

  1055 	CContent *content = CContent::NewLC(uri);

  1056 	CData *data = content->OpenContentL(EPeek, uniqueId);

  1057 	result = data->GetStringAttribute(attribute, value);

  1058 	delete data;

  1059 	if(result != expectedResult)

  1060 		{

  1061 		SetTestStepResult(EFail);

  1062 		INFO_PRINTF3(_L("CData::GetStringAttribute() Expected result: %d, actual result: %d"), expectedResult, result);

  1063 		}

  1064 	if(value != expectedValue)

  1065 		{

  1066 		SetTestStepResult(EFail);

  1067 		INFO_PRINTF3(_L("CData::GetStringAttribute() Expected value: %S, actual result: %S"), &expectedValue, &value);

  1068 		}

  1069 

  1070 	CleanupStack::PopAndDestroy(content);		

  1071     		

  1072 	__UHEAP_MARKEND;

  1073 	return TestStepResult();

  1074 

  1075 	}

  1076 

  1077 

  1078 

  1079 

  1080 /* 

  1081  * Step reads from a CData from multiple threads

  1082  *

  1083  */

  1084 

  1085 CCAFMultiThreadCDataStep::~CCAFMultiThreadCDataStep()

  1086 	{

  1087 	}

  1088 

  1089 CCAFMultiThreadCDataStep::CCAFMultiThreadCDataStep(CCAFServer& aParent)

  1090 : iParent(aParent)

  1091 	{

  1092 	SetTestStepName(KCAFMultiThreadCDataStep);

  1093 	}

  1094 

  1095 TVerdict CCAFMultiThreadCDataStep::doTestStepL()

  1096 	{

  1097 	TBuf8<2> buf;

  1098 

  1099 	__UHEAP_MARK;

  1100 	_LIT(KCDataThread,"CData_Thread");

  1101 

  1102 	SetTestStepResult(EInconclusive);

  1103 	

  1104 	INFO_PRINTF1(_L("Multi Thread CData Test"));

  1105 	

  1106 	TPtrC uri;

  1107 	GetStringFromConfig(ConfigSection(),_L("URI"),uri);

  1108 

  1109 	INFO_PRINTF1(_L("Creating data object from content"));

  1110 	CContent* content = CContent::NewLC(uri);

  1111 	CData* data = content->OpenContentL(EPeek);

  1112 	CleanupStack::PushL(data);

  1113 

  1114 	TInt size, pos;

  1115 

  1116 	// Create a mutex for communication between our thread and the new thread

  1117 	RSemaphore threadSemaphore;

  1118 	threadSemaphore.CreateGlobal(KCDataThreadSemaphore(), 1, EOwnerProcess);

  1119 	threadSemaphore.Wait(); 

  1120 

  1121 	// fire up a new thread, stack size and heap size 8k, might need to be bigger in the future 

  1122 	RThread readerThread;

  1123 	User::LeaveIfError(readerThread.Create(KCDataThread(),CCAFMultiThreadCDataStep::ReaderThreadEntry,8192, KMinHeapSize, 8192, (TAny *) data, EOwnerProcess));

  1124 	

  1125 	// request notification of thread completion

  1126 	TRequestStatus stat;

  1127 	readerThread.Logon(stat);

  1128 	readerThread.Resume();	

  1129 	

  1130 	data->DataSizeL(size);

  1131 	pos = size/2;

  1132 	data->Seek(ESeekStart,pos);

  1133 	data->Read(buf);

  1134