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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32test/iic/t_iic.cpp

//

// This file interacts with test-specific LDD to instigate tests of functionality

// that would normally be invoked by kernel-side device driver clients of the IIC.

#include <e32test.h>

#include <e32cmn.h>

#include <e32cmn_private.h>

#include <e32def.h>

#include <e32def_private.h>

#include "t_iic.h"

//for memory leak checking

#include <e32svr.h>

#include <u32hal.h>

_LIT(testName,"t_iic");

_LIT(KIicProxyFileNameCtrlLess, "iic_client_ctrless.ldd");		// Kernel-side proxy LDD acting as a client of the IIC

_LIT(KIicProxyFileNameRootCtrlLess, "iic_client_ctrless");

_LIT(KIicProxySlaveFileNameCtrlLess, "iic_slaveclient_ctrless.ldd");	// Kernel-side proxy LDD acting as a slave client of the IIC

_LIT(KIicProxySlaveFileNameRootCtrlLess, "iic_slaveclient_ctrless");

_LIT(KIicProxyFileName, "iic_client.ldd");		// Kernel-side proxy LDD acting as a client of the IIC

_LIT(KIicProxyFileNameRoot, "iic_client");

_LIT(KIicProxySlaveFileName, "iic_slaveclient.ldd");	// Kernel-side proxy LDD acting as a slave client of the IIC

_LIT(KIicProxySlaveFileNameRoot, "iic_slaveclient");

//These are used to exercise stub functions.

_LIT(KIicProxyFileNameStubs, "iic_client_stubs.ldd");

_LIT(KIicProxyFileNameRootStubs, "iic_client_stubs");

_LIT(KIicProxySlaveFileNameStubs, "iic_slaveclient_stubs.ldd");

_LIT(KIicProxySlaveFileNameRootStubs, "iic_slaveclient_stubs");

#ifdef IIC_SIMULATED_PSL

_LIT(KSpiFileNameCtrlLess, "spi_ctrless.pdd");	// Simulated PSL bus implementation

_LIT(KI2cFileNameCtrlLess, "i2c_ctrless.pdd");  // Simulated PSL bus implementation

_LIT(KIicPslFileName, "iic_testpsl.pdd");	// Simulated PSL implementation

_LIT(KSpiFileName, "spi.pdd");	// Simulated PSL bus implementation

_LIT(KI2cFileName, "i2c.pdd");  // Simulated PSL bus implementation

//These are used to exercise stubs. The I2C pdd to use for stub tests will depend on

//whether Master, Slave mode has been selected. 

#if defined(MASTER_MODE)&&!defined(SLAVE_MODE)

_LIT(KI2cFileNameStubs, "i2c_slavestubs_ctrless.pdd");

#elif !defined(MASTER_MODE)&& defined(SLAVE_MODE)

_LIT(KI2cFileNameStubs, "i2c_masterstubs_ctrless.pdd");

#else

_LIT(KI2cFileNameStubs, "i2c_ctrless.pdd");

#endif

#endif

_LIT(KIicPslFileNameRoot, "iic.pdd");

// Specify a stand-alone channel

GLDEF_D TBool aStandAloneChan;

GLDEF_D RTest gTest(testName);

// SPI has Master channel numbers 1,2 and 4, Slave channel number 3

GLDEF_D RBusDevIicClient gChanMasterSpi;

GLDEF_D RBusDevIicClient gChanSlaveSpi;

// I2C has Master channel numbers 10 and 11, if built with MASTER_MODE, only

// I2C has Slave channel numbers 12 and 13, if built with SLAVE_MODE, only

// I2C has Master channel number 10 and Slave channel number 11 if built with both MASTER_MODE and SLAVE_MODE

GLDEF_D RBusDevIicClient gChanMasterI2c;

GLDEF_D RBusDevIicClient gChanSlaveI2c;

LOCAL_C TInt CreateSingleUserSideTransfer(TUsideTferDesc*& aTfer, TInt8 aType, TInt8 aBufGran, TDes8* aBuf, TUsideTferDesc* aNext)

// Utility function to create a single transfer

	{

	aTfer = new TUsideTferDesc();

	if(aTfer==NULL)

		return KErrNoMemory;

	aTfer->iType=aType;

	aTfer->iBufGranularity=aBufGran;

	aTfer->iBuffer = aBuf;

	aTfer->iNext = aNext;

	return KErrNone;

	}

LOCAL_C TInt CreateSingleUserSideTransaction(TUsideTracnDesc*& aTracn, TBusType aType, TDes8* aHdr, TUsideTferDesc* aHalfDupTrans, TUsideTferDesc* aFullDupTrans, TUint8 aFlags, TAny* aPreambleArg, TAny* aMultiTranscArg)

// Utility function to create a single transaction

	{

	aTracn = new TUsideTracnDesc();

	if(aTracn==NULL)

		return KErrNoMemory;

	aTracn->iType=aType;

	aTracn->iHeader=aHdr;

	aTracn->iHalfDuplexTrans=aHalfDupTrans;

	aTracn->iFullDuplexTrans=aFullDupTrans;

	aTracn->iFlags=aFlags;

	aTracn->iPreambleArg = aPreambleArg;

	aTracn->iMultiTranscArg = aMultiTranscArg;

	return KErrNone;

	}

//----------------------------------------------------------------------------------------------

//! @SYMTestCaseID      KBASE-T_IIC-2402

//! @SYMTestType        UT

//! @SYMPREQ            PREQ2128,2129

//! @SYMTestCaseDesc    This test case test the Master channel basic functionality

//! @SYMTestActions     0) Create a transaction and invoke the synchronous Queue Transaction API

//!

//!						1) Re-use the transaction and invoke asynchronous Queue Transaction API. Wait for

//|						   the TRequestStatus to be completed.

//!

//!						2) Instruct the Kernel-side proxy client to instigate testing of priority queuing.

//!						   The proxy uses controlIO to block the transaction queue, then queues 5 transactions in reverse

//!						   priority order. The proxy then uses controlIO to unblock the transaction queue and checks that

//!						   the transactions complete in priority order.

//!

//!						3) Attempt to cancel a previously-completed asynchronous request for a queued transaction

//!

//!						4) Use controlio to block request completion. Issue two asynchronous Queue Transaction requests.

//!						   Request cancellation of the second transaction. Wait for completion of the TRequestStatus for

//!						   the second request. Attempt to de-register the channel. Use controlio to unblock request completion.

//!						   Wait for completion of the TRequestStatus for the first request.

//!

//!						5) Attempt to de-register a channel that is not busy.

//!

//!						6) Attempt to queue a transaction on an invalid (de-registered) channel

//!

//!						7) Instruct the Kernel-side proxy client to instigate construction of a valid full duplex transaction.

//!

//!						8) Instruct the Kernel-side proxy client to instigate construction of a invalid full duplex transaction,

//!						   where both transfer in same direction

//!

//!						9) Instruct the Kernel-side proxy client to instigate construction of a invalid full duplex transaction,

//!						   where with different node length (not the number of node on opposite linklist ) at the same

//!						   position on the opposite transfer linklist

//!

//!						10) Instruct the Kernel-side proxy client to instigate construction of a valid full duplex transaction,

//!						   with different size for the last node

//!

//!						11) Instruct the Kernel-side proxy client to instigate construction of a valid full duplex transaction,

//!						   with different number of transfer

//!

//!

//! @SYMTestExpectedResults 0) Kernel-side proxy client should return with KErrNone, exits otherwise.

//!						1) Kernel-side proxy client should return with KErrNone, exits otherwise. TRequestStatus should

//!						   be set to KErrNone, exits otherwise.

//!						2) Kernel-side proxy client should return with KErrNone, exits otherwise.

//!						3) Kernel-side proxy client should return with KErrNone, exits otherwise.TRequestStatus should

//!						   be set to KErrNone, exits otherwise.

//!						4) The TRequestStatus for the cancelled request should be set to KErrCancel, exits otherwise.

//!						   The attempt to de-register the channel should return KErrInUse, exits otherwise. The

//!						   TRequestStatus for the first request should be set to KErrNone, exits otherwise.

//!						5) Kernel-side proxy client should return with KErrNone or KErrArgument, exits otherwise.

//!						6) Kernel-side proxy client should return with KErrArgument, exits otherwise.

//!						7) Kernel-side proxy client should return with KErrNone, exits otherwise.

//!						8) Kernel-side proxy client should return with KErrNotSupported, exits otherwise.

//!						9) Kernel-side proxy client should return with KErrNotSupported, exits otherwise.

//!						10) Kernel-side proxy client should return with KErrNone, exits otherwise.

//!						11) Kernel-side proxy client should return with KErrNone, exits otherwise.

//!

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

//----------------------------------------------------------------------------------------------

LOCAL_C TInt MasterBasicTests()

//

//	Exercise the Master Channel API with trivial data

//

	{

	gTest.Printf(_L("\n\nStarting MasterBasicTests\n"));

	TInt r=KErrNone;

	TUint32 busIdSpi = 0;

	// Use the SPI bus

	// SPI uses channel numbers 1,2,3 and 4

	SET_BUS_TYPE(busIdSpi,ESpi);

	SET_CHAN_NUM(busIdSpi,2);

	TConfigSpiBufV01* spiBuf = NULL;

	// aDeviceId=1 ... 100kHz ... aTimeoutPeriod=100 ... aTransactionWaitCycles=10 - arbitrary paarmeters.

	r = CreateSpiBuf(spiBuf, ESpiWordWidth_8, 100000, ESpiPolarityLowRisingEdge, 100 ,ELittleEndian, EMsbFirst, 10, ESpiCSPinActiveLow);

	gTest(r==KErrNone);

	// Use a single transfer

	_LIT(halfDuplexText,"Half Duplex Text");

	TBuf8<17> halfDuplexBuf_8;

	halfDuplexBuf_8.Copy(halfDuplexText);

	TUsideTferDesc* tfer = NULL;

	r = CreateSingleUserSideTransfer(tfer, EMasterWrite, 8, &halfDuplexBuf_8, NULL);

	gTest(r==KErrNone);

	// Create the transaction object

	TUsideTracnDesc* tracn = NULL;

	r = CreateSingleUserSideTransaction(tracn, ESpi, spiBuf, tfer, NULL, 0, NULL, NULL);

	gTest(r==KErrNone);

	// Test basic queueing operations

	// inline TInt QueueTransaction(TInt aBusId, TUsideTracnDesc* aTransaction)

	gTest.Printf(_L("\n\nStarting synchronous QueueTransaction \n"));

	r = gChanMasterSpi.QueueTransaction(busIdSpi, tracn);

	gTest.Printf(_L("Synchronous QueueTransaction returned = %d\n"),r);

	gTest(r==KErrNone); 

    // inline void QueueTransaction(TRequestStatus& aStatus, TInt aBusId, TUsideTracnDesc* aTransaction)

	gTest.Printf(_L("\n\nStarting asynchronous QueueTransaction \n"));

	TRequestStatus status;

	gChanMasterSpi.QueueTransaction(status, busIdSpi, tracn);

	User::WaitForRequest(status);

	if(status != KErrNone)

		{

		gTest.Printf(_L("TRequestStatus value after queue = %d\n"), status.Int());

		gTest(EFalse);

		}

	// Test message with priorities

	gTest.Printf(_L("\n\nStarting test for message with priorities\n\n"),r);

	r = gChanMasterSpi.TestPriority(busIdSpi);

	gTest(r==KErrNone);

	// Test cancel operation (on previously completed request)

	// inline void CancelAsyncOperation(TRequestStatus* aStatus, TInt aBusId)	{TInt* parms[2]; parms[0]=(TInt*)aStatus; parms[1]=(TInt*)aBusId;DoCancel((TInt)&parms[0]);}

	gTest.Printf(_L("\n\nStarting CancelAsyncOperation \n"));

	gChanMasterSpi.CancelAsyncOperation(&status, busIdSpi);

	if(status == KRequestPending)

		User::WaitForRequest(status);

	if(status != KErrNone)

		{

		gTest.Printf(_L("TRequestStatus value after (belated) cancel = %d\n"), status.Int());

		gTest(EFalse);

		}

	// Test cancel operation (on pending request)

	// Also test that a channel with a transaction queued can not be de-registered.

	// For this:

	// (1) create a second transaction object

	// (2) use controlio/StaticExtension to block request completion

	// (3) use asynchronous queue transaction for the two transaction objects

	// (4) request cancellation of the second request

	// (5) check that the TRequestStatus object associated with the second request is completed with KErrCancel

	// (6) check that attempt to de-register the channel fails with KErrInUse

	// (7) use controlio/StaticExtension to unblock request completion

	// (8) check that the TRequestStatus object associated with the first request is completed with KErrNone

	//

	gTest.Printf(_L("\n\nStarting (successful) cancellation test\n\n"),r);

	_LIT(halfDuplexText2,"2 Half Duplex Text 2");

	TBuf8<21> halfDuplexBuf2_8;

	halfDuplexBuf2_8.Copy(halfDuplexText2);

	TUsideTferDesc* tfer2 = NULL;

	r = CreateSingleUserSideTransfer(tfer2, EMasterRead, 16, &halfDuplexBuf2_8, NULL);

	gTest(r == KErrNone);

	TUsideTracnDesc* tracn2 = NULL;

	delete spiBuf;

	spiBuf = NULL;

	// aDeviceId=1 ... 100kHz ... aTimeoutPeriod=100 ... aTransactionWaitCycles=10 - arbitrary paarmeters.

	r = CreateSpiBuf(spiBuf, ESpiWordWidth_8, 100000, ESpiPolarityLowRisingEdge, 100 ,ELittleEndian, EMsbFirst, 10, ESpiCSPinActiveLow);

	gTest(r == KErrNone);

	r = CreateSingleUserSideTransaction(tracn2, ESpi, spiBuf, tfer2, NULL, 0, NULL, NULL);

	gTest(r == KErrNone);

	//

	gTest.Printf(_L("Invoking BlockReqCompletion\n"));

	r = gChanMasterSpi.BlockReqCompletion(busIdSpi);

	gTest.Printf(_L("BlockReqCompletion returned = %d\n"),r);

	gTest(r == KErrNone);

	//

	gTest.Printf(_L("Queueing first transaction \n"));

	gChanMasterSpi.QueueTransaction(status, busIdSpi, tracn);

	TRequestStatus status2;

	gTest.Printf(_L("Queueing second transaction \n"));

	gChanMasterSpi.QueueTransaction(status2, busIdSpi, tracn2);

	//

	User::After(50000);

	//

	gTest.Printf(_L("Issuing Cancel for second transaction\n"));

	gChanMasterSpi.CancelAsyncOperation(&status2, busIdSpi);

	gTest.Printf(_L("Returned from Cancel for second transaction\n"));

	if(status2 == KRequestPending)

		User::WaitForRequest(status2);

	if(status2 != KErrCancel)

		{

		gTest.Printf(_L("TRequestStatus (2) value after cancel = %d\n"), status2.Int());

		gTest(EFalse);

		}

	// If it is stand-alone channel, the client is reponsible for channel creation.

	// So the RegisterChan and DeRegisterChan are not needed.

	if (aStandAloneChan == 0)

		{

		gTest.Printf(_L("Invoking DeRegisterChan\n"));

		r = gChanMasterSpi.DeRegisterChan(busIdSpi);

		gTest.Printf(_L("DeRegisterChan returned = %d\n"),r);

		gTest(r==KErrInUse);

		}

	//

	gTest.Printf(_L("Invoking UnlockReqCompletion\n"));

	r = gChanMasterSpi.UnblockReqCompletion(busIdSpi);

	gTest.Printf(_L("UnblockReqCompletion returned = %d\n"),r);

	//

	User::After(50000);

	//

	User::WaitForRequest(status);

	if(status != KErrNone)

		{

		gTest.Printf(_L("TRequestStatus value after queue = %d\n"), status.Int());

		gTest(EFalse);

		}

	// Clean up

	delete spiBuf;

	delete tfer;

	delete tracn;

	delete tfer2;

	delete tracn2;

	gTest.Printf(_L("\n\nStarting full duplex transaction creation test\n\n"),r);

	TUint32 busIdSpiFd = 0;

	// Use the SPI bus

	// SPI uses channel numbers 1,2,3 and 4

	SET_BUS_TYPE(busIdSpi,ESpi);

	SET_CHAN_NUM(busIdSpi,4);

	// Test creating a valid full duplex transaction

	gTest.Printf(_L("\n\nStarting valid full duplex transaction test\n\n"),r);

	r = gChanMasterSpi.TestValidFullDuplexTrans(busIdSpiFd);

	gTest(r==KErrNone);

	// Test creating a full duplex transaction with both transfer in same direction (invalid)

	gTest.Printf(_L("\n\nStarting invalid direction full duplex transaction test\n\n"),r);

	r = gChanMasterSpi.TestInvalidFullDuplexTrans1(busIdSpiFd);

	gTest.Printf(_L("Full duplex transaction with invalid direction returned = %d\n"),r);

	gTest(r==KErrNotSupported);

	// Test creating a full duplex transaction with different node length (not the number of node on opposite linklist )

	// at the same position on the opposite transfer linklist

	gTest.Printf(_L("\n\nStarting invalid transfer length full duplex transaction test\n\n"),r);

	r = gChanMasterSpi.TestInvalidFullDuplexTrans2(busIdSpiFd);

	gTest(r==KErrNotSupported);

	// Test creating a valid full duplex transaction with different size for the last node

	gTest.Printf(_L("\n\nStarting valid full duplex transaction test with diff size last node\n\n"),r);

	r = gChanMasterSpi.TestLastNodeFullDuplexTrans(busIdSpiFd);

	gTest(r==KErrNone);

	// Test creating a valid full duplex transaction with different number of transfer

	gTest.Printf(_L("\n\nStarting valid full duplex transaction test with diff number of transfer\n\n"),r);

	r = gChanMasterSpi.TestDiffNodeNumFullDuplexTrans(busIdSpiFd);

	gTest(r==KErrNone);

	return KErrNone;

	}

//----------------------------------------------------------------------------------------------

//! @SYMTestCaseID      KBASE-T_IIC-2403

//! @SYMTestType        UT

//! @SYMPREQ            PREQ2128,2129

//! @SYMTestCaseDesc    This test case tests the Master channel data handling for transactions

//! @SYMTestActions     0) Instruct the kernel-side proxy to construct a transaction of pre-defined data

//!						   and inform the simulated bus to expect to receive this data. Then the proxy invokes

//!						   the synchronous Queue Transaction API. On receipt of the transaction, the simulated bus

//!						   checks the header and transafer content of the transaction to confirm that it is correct.

//!

//! @SYMTestExpectedResults 0) Kernel-side proxy client should return with KErrNone, exits otherwise.

//!

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

//----------------------------------------------------------------------------------------------

LOCAL_C TInt MasterTransactionTests()

//

//	Exercise the Master Channel API with trivial data

//

	{

	gTest.Printf(_L("\n\nStarting MasterTransactionTests\n"));

	TInt r = KErrNone;

	// Prove that the simulated bus can access the transfer data contained within a transaction

	// Do this by instructing the proxy client to:

	// (1) Inform the bus of the test about to be informed

	// (2) Send a transaction with a known number of transfers with known data

	// (3) Check the result announced by the bus.

	//

	// Use the SPI bus

	// SPI uses channel numbers 1,2,3 and 4

	TUint32 busIdSpi = 0;

	SET_BUS_TYPE(busIdSpi,ESpi);

	SET_CHAN_NUM(busIdSpi,4);	// Master, Full-duplex - required by TestBufferReUse

	r = gChanMasterSpi.TestTracnOne(busIdSpi);

	gTest.Printf(_L("TestTracnOne returned = %d\n"),r);

	gTest(r==KErrNone);

	// Test that transfer and transaction buffers can be modifed for re-use

	// This test modifies the content of a full-duplex transaction - so a full-duplex channel must be used

	TRequestStatus status;

	gChanMasterSpi.TestBufferReUse(busIdSpi, status);

	User::WaitForRequest(status);

	r=status.Int();

	if(r != KErrNone)

		{

		gTest.Printf(_L("TRequestStatus value after CaptureChannel = %d\n"),r);

		gTest(r==KErrCompletion);

		}

	return KErrNone;

	}

//----------------------------------------------------------------------------------------------

//! @SYMTestCaseID      KBASE-T_IIC-2401

//! @SYMTestType        UT

//! @SYMPREQ            PREQ2128,2129

//! @SYMTestCaseDesc    This test case test the Master channel preamble and multi-transaction functionality.

//! @SYMTestActions     0) Create a transaction that requires preamble support, and queue it for processing

//!

//!						1) If the test has been invoked for preamble testing, wait for the preamble-specific

//!						   TRequestStatus to be completed.

//!

//!						2) If the test has been invoked for multi-transaction testing, wait for the multi-transaction

//!						   -specific TRequestStatus to be completed.

//!

//!

//! @SYMTestExpectedResults 0) Kernel-side proxy client should return with KErrNone, exits otherwise.

//!						1) If waiting on the preamble-specific TRequestStatus, it should be set to KErrNone, exists otherwise.

//!						2) If waiting on the multi-transaction-specific TRequestStatus, it should be set to KErrNone, exists otherwise.

//!

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

//----------------------------------------------------------------------------------------------

LOCAL_C TInt MasterExtTests(TUint8 aFlags)

//

//	Exercise the Master Channel API for Preamble functionality

//

//  For the multi-transaction test, a bus Master might not know 

//  how much data to write to a Slave until it performs a single read on it. 

//  However, specifying a read separately from the subsequent write 

//  introduces the risk of allowing another transaction to go ahead of the 

//  following write and thus invalidating it. The multi-transaction feature of IIC

//  allows a callback to be called(in the context of the bus channel) after 

//  the transfers of a preliminary transaction have taken place 

//  (could be a single read), without completing the overall transaction,

//  then extend the delayed transaction by inserting more transfers

//

	{

	gTest.Printf(_L("\n\nStarting MasterExtTests\n"));

	TInt r = KErrNone;

	// Create a transaction that requires preamble support

	// To prove required operation has executed, make callback complete a TRequestStatus object

	TRequestStatus preamblestatus;

	TRequestStatus multitranscstatus;

	// Use the SPI bus

	// SPI uses channel numbers 1,2,3 and 4

	TUint32 busIdSpi = 0;

	SET_BUS_TYPE(busIdSpi, ESpi);

	SET_CHAN_NUM(busIdSpi, 1);

	TConfigSpiBufV01* spiBuf = NULL;

	// aDeviceId=1 ... 100kHz ... aTimeoutPeriod=100 ... aTransactionWaitCycles=10 - arbitrary paarmeters.

	r = CreateSpiBuf(spiBuf, ESpiWordWidth_8, 100000,

	        ESpiPolarityLowRisingEdge, 100, ELittleEndian, EMsbFirst, 10,

	        ESpiCSPinActiveLow);

	if (r != KErrNone)

		return r;

	// Use a single transfer

	_LIT(extText, "Ext Text");

	TBuf8<14> extBuf_8;

	extBuf_8.Copy(extText);

	TUsideTferDesc* tfer = NULL;

	r = CreateSingleUserSideTransfer(tfer, EMasterRead, 8, &extBuf_8, NULL);

	if (r != KErrNone)

		{

		delete spiBuf;

		return r;

		}

	// Create the transaction object

	TUsideTracnDesc* tracn = NULL;

	r = CreateSingleUserSideTransaction(tracn, ESpi, spiBuf, tfer, NULL,

	        aFlags, (TAny*) &preamblestatus, (TAny*) &multitranscstatus);

	if (r != KErrNone)

		{

		delete spiBuf;

		delete tfer;

		return r;

		}

	// Send the transaction to the kernel-side proxy

	// inline TInt QueueTransaction(TInt aBusId, TUsideTracnDesc* aTransaction)

	gTest.Printf(_L("\nInvoke synchronous QueueTransaction for preamble test %x\n"), tracn);

	r = gChanMasterSpi.QueueTransaction(busIdSpi, tracn);

	gTest.Printf(_L("synchronous QueueTransaction returned = %d\n"), r);

	if (r == KErrNone)

		{

		// ... and wait for the TRequestStatus object to be completed

		if (aFlags & KTransactionWithPreamble)

			{

			User::WaitForRequest(preamblestatus);

			r = preamblestatus.Int();

			if (r != KErrNone)

				{

				gTest.Printf(_L("MasterPreambleTests: TRequestStatus completed with = %d\n"), r);

				}

			}