// 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");

 #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

 #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);

 				}

 			}

 		if (aFlags & KTransactionWithMultiTransc)

 			{

 			User::WaitForRequest(multitranscstatus);

 			if (r != KErrNone)

 				{

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

 				}

 			}

 		}

 	delete spiBuf;

 	delete tfer;

 	delete tracn;

 	return r;

 	}

 #ifdef SLAVE_MODE

 LOCAL_C TInt CreateSlaveChanI2cConfig(TConfigI2cBufV01*& aI2cBuf, TUint32& aBusIdI2c, TUint8 aChanNum)

 	{

 	// Initialise TConfigI2cBufV01 and the Bus Realisation Config for gChanSlaveI2c.

 	// Customised:

 	// - token containing the bus realisation variability.

 	// - pointer to a descriptor containing the device specific configuration option applicable to all transactions.

 	// - reference to variable to hold a platform-specific cookie that uniquely identifies the channel instance to be

 	//   used by this client

 	aBusIdI2c = 0;

 	SET_BUS_TYPE(aBusIdI2c,EI2c);

 	SET_CHAN_NUM(aBusIdI2c,aChanNum);

 	//

 	// clock speed=36Hz, aTimeoutPeriod=100 - arbitrary parameter

 	TInt r=CreateI2cBuf(aI2cBuf, EI2cAddr7Bit, 36, ELittleEndian, 100);

 	return r;

 	}

 LOCAL_C TInt SyncCaptureGChanSlaveI2c(TInt& aChanId, TConfigI2cBufV01* aI2cBuf, TUint32 aBusIdI2c)

 	{

 	// Synchronous capture of a Slave channel. Need to provide:

 	// - token containing the bus realisation variability.

 	// - pointer to a descriptor containing the device specific configuration option applicable to all transactions.

 	// - reference to variable to hold a platform-specific cookie that uniquely identifies the channel instance to be used by this client

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

 	TInt r = gChanSlaveI2c.CaptureChannel(aBusIdI2c, aI2cBuf, aChanId );

 	gTest.Printf(_L("Synchronous CaptureChannel returned = %d, aChanId=0x%x\n"),r,aChanId);

 	return r;

 	}

 LOCAL_C TInt AsyncCaptureGChanSlaveI2c(TInt& aChanId, TConfigI2cBufV01* aI2cBuf, TUint32 aBusIdI2c)

 	{

 	// Asynchronous capture of a Slave channel. Need to provide:

 	// - token containing the bus realisation variability.

 	// - pointer to a descriptor containing the device specific configuration option applicable to all transactions.

 	// - reference to variable to hold a platform-specific cookie that uniquely identifies the channel instance to be used by this client

 	// - pointer to TRequestStatus used to indicate operation completion

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

 	TRequestStatus status;

 	TInt r = gChanSlaveI2c.CaptureChannel(aBusIdI2c, aI2cBuf, aChanId, status );

 	gTest(r==KErrNone);

 	User::WaitForRequest(status);

 	r=status.Int();

 	if(r != KErrCompletion)

 		{

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

 		gTest(r==KErrCompletion);

 		}

 	gTest.Printf(_L("Asynchronous CaptureChannel gave aChanId=0x%x\n"),aChanId);

 	return KErrNone;

 	}

 #endif

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

 //! @SYMTestCaseID      KBASE-T_IIC-2399

 //! @SYMTestType        UT

 //! @SYMPREQ            PREQ2128,2129

 //! @SYMTestCaseDesc    This test case tests Slave channel capture and release APIs.

 //! @SYMTestActions     0) Perform synchronous capture of a channel

 //!

 //!						1) Release the channel

 //!

 //!						2) Perform asynchronous capture of a channel

 //!

 //!						3) Attempt synchronous capture of a channel that is already captured

 //!

 //!						4) Attempt asynchronous capture of a channel that is already captured

 //!

 //!						5) Release the channel

 //!

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

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

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

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

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

 //!						   TRequestStatus should be set to KErrInUse, exits otherwise.

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

 //!

 //! @SYMTestPriority        High

 //! @SYMTestStatus          Implemented

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

 LOCAL_C TInt SlaveChannelCaptureReleaseTests()

 //

 //	Exercise the Slave Channel API for channel capture and release

 //

 	{

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

 	TInt r=KErrNone;

 #ifdef SLAVE_MODE

 	// Create a I2C configuration buffer and the configuration data for use in capturing gChanSlaveI2c

 	TUint32 busIdI2c = 0;

 	TConfigI2cBufV01* i2cBuf=NULL;

 	r=CreateSlaveChanI2cConfig(i2cBuf, busIdI2c, 11);	// 11 is the Slave channel number

 	gTest(r==KErrNone);

 	// Synchronous capture of a Slave channel.

 	TInt chanId = 0; // Initialise to zero to silence compiler ...

 	r=SyncCaptureGChanSlaveI2c(chanId, i2cBuf, busIdI2c);

 	gTest(r==KErrNone);

 	//

 	// Release the channel

 	gTest.Printf(_L("\n\nInvoke ReleaseChannel for chanId=0x%x \n"),chanId);

 	r = gChanSlaveI2c.ReleaseChannel( chanId );

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

 	gTest(r==KErrNone);

 	//

 	// Asynchronous capture of a Slave channel.

 	chanId = 0; // Re-initialise to zero to silence compiler ...

 	r=AsyncCaptureGChanSlaveI2c(chanId, i2cBuf, busIdI2c);

 	gTest(r==KErrNone);

 	// Try capturing a slave channel that is already captured

 	//

 	// Create another instance of a client, and use to attempt duplicated capture

 	TInt dumChanId = 0; // Initialise to zero to silence compiler ...

 	RBusDevIicClient tempChanSlaveI2c;

 	TBufC<24> proxySlaveName;

 	if(aStandAloneChan == 0)

 		proxySlaveName = KIicProxySlaveFileNameRoot;

 	else

 		proxySlaveName = KIicProxySlaveFileNameRootCtrlLess;

 	r = tempChanSlaveI2c.Open(proxySlaveName);

 	gTest(r==KErrNone);

 	r = tempChanSlaveI2c.InitSlaveClient();

 	gTest(r==KErrNone);

 	//

 	// Synchronous capture

 	gTest.Printf(_L("\n\nStarting attempted synchronous CaptureChannel of previously-captured channel\n"));

 	r = tempChanSlaveI2c.CaptureChannel(busIdI2c, i2cBuf, dumChanId );

 	gTest.Printf(_L("Synchronous CaptureChannel returned = %d, dumChanId=0x%x\n"),r,dumChanId);

 	gTest(r==KErrInUse);

 	//

 	// Asynchronous capture

 	dumChanId = 0;

 	gTest.Printf(_L("\n\nStarting attempted asynchronous CaptureChannel of previously-captured channel\n"));

 	TRequestStatus status;

 	r = tempChanSlaveI2c.CaptureChannel(busIdI2c, i2cBuf, dumChanId, status );

 	gTest(r==KErrNone);

 	User::WaitForRequest(status);

 	r=status.Int();

 	if(r != KErrInUse)

 		{

 		gTest.Printf(_L("TRequestStatus value after attempted CaptureChannel of previously-captured channel = %d\n"),r);

 		gTest(r==KErrInUse);

 		}

 	gTest.Printf(_L("Asynchronous CaptureChannel gave dumChanId=0x%x\n"),dumChanId);

 	tempChanSlaveI2c.Close();

 	//

 	// Clean up, release the channel

 	r = gChanSlaveI2c.ReleaseChannel( chanId );

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

 	gTest(r==KErrNone);

 	delete i2cBuf;

 #else

 	gTest.Printf(_L("\nSlaveChannelCaptureReleaseTests only supported when SLAVE_MODE is defined\n"));

 #endif

 	return r;

 	}

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

 //! @SYMTestCaseID      KBASE-T_IIC-2400

 //! @SYMTestType        UT

 //! @SYMPREQ            PREQ2128,2129

 //! @SYMTestCaseDesc    This test case tests Slave channel capture operation for receive and transmit of data

 //! @SYMTestActions     0) Check that the timeout threshold values can be updated

 //!

 //!						1) Check that an Rx Buffer can be registered, and that a replacement buffer can be registered in its place

 //!						   if a notification has not been requested.

 //!

 //!						2) Specify a notification trigger for Rx events

 //!

 //!						3) Attempt to register a replacement Rx buffer

 //!

 //!						4) Use controlIO to instruct the simulated bus to indicate that it has received the required number of words

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

 //!

 //!						5) Specify a notification trigger for Rx events, use controlIO to instruct the simulated bus to indicate that

 //!						   it has received less than the required number of words and wait for the TRequestStatus to be completed.

 //!

 //!						6) Specify a notification trigger for Rx events, use controlIO to instruct the simulated bus to indicate that

 //!						   it has received more than the required number of words and wait for the TRequestStatus to be completed.

 //!

 //!						7) Repeat steps 1-6, but for Tx

 //!

 //!						8) Specify a notification trigger for Rx and Tx events. Use controlIO to instruct the simulated bus to indicate that

 //!						   it has received the required number of words, then that it has transmitted the required number of words, and wait

 //!						   for the TRequestStatus to be completed.

 //!

 //!						9) Repeat step 8, but simulate Tx, then Rx.

 //!

 //!						10) Specify a notification trigger for bus error events. Use controlIO to instruct the simulated bus to indicate that

 //!						    it has encountered a bus error, and wait for the TRequestStatus to be completed.

 //!

 //!						11) Use controlIO to instruct the simulated bus to block Master response. Specify a notification trigger for bus error

 //!						    events. Use controlIO to instruct the simulated bus to indicate that it has received more than the required number

 //!						    of words. Wait for the TRequestStatus to be completed (with KErrNone). Specify a notification trigger for Tx and

 //!							Tx Overrun, then use controlIO to instruct the simulated bus to unblock Master responses.Wait for the TRequestStatus

 //!							to be completed.

 //!

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

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

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

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

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

 //!						   TRequestStatus should be set to KErrNone, exits otherwise.

 //!						5) Kernel-side proxy client should return with KErrNone for both API calls, exits otherwise. The associated

 //!						   TRequestStatus should be set to KErrNone, exits otherwise.

 //!						6) Kernel-side proxy client should return with KErrNone for both API calls, exits otherwise. The associated

 //!						   TRequestStatus should be set to KErrNone, exits otherwise.

 //!						7) Results should be the same as for steps 1-6.

 //!						8) Kernel-side proxy client should return with KErrNone for each API call, exits otherwise. The associated

 //!						   TRequestStatus should be set to KErrNone, exits otherwise.

 //!						9) Kernel-side proxy client should return with KErrNone for each API call, exits otherwise. The associated

 //!						   TRequestStatus should be set to KErrNone, exits otherwise.

 //!						10) Kernel-side proxy client should return with KErrNone for each API call, exits otherwise. The associated

 //!						   TRequestStatus should be set to KErrNone, exits otherwise.

 //!						11) Kernel-side proxy client should return with KErrNone for each API call, exits otherwise. The associated

 //!						   TRequestStatus should be set to KErrNone in both cases, exits otherwise.

 //!

 //! @SYMTestPriority        High

 //! @SYMTestStatus          Implemented

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

 LOCAL_C TInt SlaveRxTxNotificationTests()

 //

 //	Exercise the Slave channel operation for receive and transmit of data

 //

 // The means to supply a buffer to be filled with data received from the Master, and the number of words expected.

 // It is only after the reception of the number of words specified that the notification should be issued

 // (or on under-run/overrun/timeout/bus specific error).

 //

 // The means to supply a buffer with data to be transmitted to the Master, and the number of words to transmit.

 // It is only after the transmission of the number of words specified that the notification should be issued

 // (or under-run/overrun/timeout/bus specific error).

 //

 // The means to enable and disable the events which will trigger the notification callback. These events are:

 // 1)	the complete reception of the number of words specified,

 // 2)	the complete transmission of the number of words specified,

 // 3)	errors: receive buffer under-run (the Master terminates the transaction or reverts the direction of

 //		transfer before all expected data has been received), receive buffer overrun

 //		(Master attempts to write more data than this channel expected to receive), transmit buffer overrun

 //		(Master attempts to read more data than supplied by client), transmit buffer under-run

 //		(the Master terminates the transaction or reverts the direction of transfer before all expected data

 //		has been transmitted to it), access timeout(1) error, or bus specific error (e.g. collision, framing).

   {

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

 	TInt r=KErrNone;

 #ifdef SLAVE_MODE

 	//Configure and capture a channel

 	gTest.Printf(_L("Create and capture channel\n"));

 	TUint32 busIdI2c;

 	TConfigI2cBufV01* i2cBuf=NULL;

 	r=CreateSlaveChanI2cConfig(i2cBuf, busIdI2c, 11);	// 11 is the Slave channel number

 	gTest(r==KErrNone);

 	TInt chanId = 0; // Initialise to zero to silence compiler ...

 	r=SyncCaptureGChanSlaveI2c(chanId, i2cBuf, busIdI2c);

 	gTest(r==KErrNone);

 	//		Update wait times for Master and Client

 	// Delegate the operation of this test to the proxy client (iic_client). The proxy will read, modify, and reinstate

 	// the timeout values.

 	gTest.Printf(_L("Starting UpdateTimeoutValues\n"));

 	r=gChanSlaveI2c.UpdateTimeoutValues(busIdI2c, chanId);

 	gTest(r==KErrNone);

 	// Receive and transmit buffers must be created by the client in Kernel heap and remain in their ownership throughout.

 	// Therefore, the kernel-side proxy will provide the buffer

 	// The buffers are of size KRxBufSizeInBytes and KRxBufSizeInBytes (currently 64)

 	//

 	//		Rx tests

 	//

 	// For Rx, specify buffer granularity=4 (32-bit words), 8 words to receive, offset of 16 bytes

 	// 64 bytes as 16 words: words 0-3 offset, words 4-11 data, words 12-15 unused

 	gTest.Printf(_L("Starting RegisterRxBuffer\n"));

 	r=gChanSlaveI2c.RegisterRxBuffer(chanId, 4, 8, 16);

 	gTest(r==KErrNone);

 	//

 	// If a buffer is already registered but a notification has not yet been requested the API should return KErrNone

 	gTest.Printf(_L("Starting (repeated) RegisterRxBuffer\n"));

 	r=gChanSlaveI2c.RegisterRxBuffer(chanId, 4, 8, 16);

 	gTest(r==KErrNone);

 	//

 	// Now set the notification trigger

 	TRequestStatus status;

 	TInt triggerMask=ERxAllBytes;

 	gTest.Printf(_L("Starting SetNotificationTrigger with ERxAllBytes\n"));

 	r=gChanSlaveI2c.SetNotificationTrigger(chanId,triggerMask,&status);

 	gTest(r==KErrNone);

 	//

 	// If a buffer is registered and a notification has been requested the API should return KErrAlreadyExists

 	gTest.Printf(_L("Starting RegisterRxBuffer (to be rejected)\n"));

 	r=gChanSlaveI2c.RegisterRxBuffer(chanId, 4, 8, 16);

 	gTest(r==KErrAlreadyExists);

 	//

 	// Now instruct the bus implementation to represent receipt of the required number of words from the bus master.

 	gTest.Printf(_L("Starting SimulateRxNWords\n"));

 	r=gChanSlaveI2c.SimulateRxNWords(busIdI2c, chanId, 8);

 	gTest(r==KErrNone);

 	//

 	// Wait for the notification

 	User::WaitForRequest(status);

 	r=status.Int();

 	if(r != KErrNone)

 		{

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

 		gTest(r==KErrNone);

 		}

 	gTest.Printf(_L("Starting Rx test completed OK\n"));

 	//

 	// Repeat for each error condition. Re-use the buffer previously registered.

 	//

 	//

 	triggerMask=ERxAllBytes|ERxUnderrun;

 	gTest.Printf(_L("Starting SetNotificationTrigger with ERxAllBytes\n"));

 	r=gChanSlaveI2c.SetNotificationTrigger(chanId,triggerMask,&status);

 	gTest(r==KErrNone);

 	// Now instruct the bus implementation to represent the bus master transmitting less words than anticipated (Rx Underrun)

 	gTest.Printf(_L("Starting SimulateRxNWords for Underrun\n"));

 	r=gChanSlaveI2c.SimulateRxNWords(busIdI2c, chanId, 6);

 	gTest(r==KErrNone);

 	//

 	// Wait for the notification

 	User::WaitForRequest(status);

 	r=status.Int();

 	if(r != KErrNone)

 		{

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

 		gTest(r==KErrNone);

 		}

 	gTest.Printf(_L("Rx Underrun test completed OK\n"));

 	// Re-set the notification trigger

 	triggerMask=ERxAllBytes|ERxOverrun;

 	gTest.Printf(_L("Starting SetNotificationTrigger\n"));

 	r=gChanSlaveI2c.SetNotificationTrigger(chanId,triggerMask,&status);

 	gTest(r==KErrNone);

 	// Now instruct the bus implementation to represent the bus master attempting to transmit more words than

 	// anticipated (Rx Overrun)

 	gTest.Printf(_L("Starting SimulateRxNWords for Overrun\n"));

 	r=gChanSlaveI2c.SimulateRxNWords(busIdI2c, chanId, 10);

 	gTest(r==KErrNone);

 	//

 	// Wait for the notification

 	User::WaitForRequest(status);

 	r=status.Int();

 	if(r != KErrNone)

 		{

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

 		gTest(r==KErrNone);

 		}

 	gTest.Printf(_L("Rx Overrun test completed OK\n"));

 	//

 	//		Tx tests

 	//

 	// For Tx, specify buffer granularity=4 (32-bit words), 12 words to transmit, offset of 8 bytes

 	// 64 bytes as 16 words: words 0-1 offset, words 2-13 data, words 14-15 unused

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

 	r=gChanSlaveI2c.RegisterTxBuffer(chanId, 4, 12, 8);

 	gTest(r==KErrNone);

 	//

 	// If a buffer is already registered but a notification has not yet been requested the API should return KErrNone

 	gTest.Printf(_L("Starting (repeated) RegisterTxBuffer\n"));

 	r=gChanSlaveI2c.RegisterTxBuffer(chanId, 4, 12, 8);

 	gTest(r==KErrNone);

 	//

 	// Re-set the notification trigger

 	// Now set the notification trigger

 	gTest.Printf(_L("Starting SetNotificationTrigger\n"));

 	triggerMask=ETxAllBytes;

 	r=gChanSlaveI2c.SetNotificationTrigger(chanId,triggerMask,&status);

 	gTest(r==KErrNone);

 	//

 	// If a buffer is already registered, a subsequent request to do the same should return KErrAlreadyExists

 	gTest.Printf(_L("Starting RegisterTxBuffer (to be rejected)\n"));

 	r=gChanSlaveI2c.RegisterTxBuffer(chanId, 4, 12, 8);

 	gTest(r==KErrAlreadyExists);

 	//

 	// Now instruct the bus implementation to represent transmission of the required number of words to the bus master.

 	gTest.Printf(_L("Starting SimulateTxNWords (to be rejected)\n"));

 	r=gChanSlaveI2c.SimulateTxNWords(busIdI2c, chanId, 12);

 	gTest(r==KErrNone);

 	//

 	// Wait for the notification

 	User::WaitForRequest(status);

 	r=status.Int();

 	if(r != KErrNone)

 		{

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

 		gTest(r==KErrNone);

 		}

 	gTest.Printf(_L("Tx test completed OK\n"));

 	//

 	// Repeat for each error condition. Re-use the buffer previously registered

 	//

 	// Re-set the notification trigger

 	gTest.Printf(_L("Starting SetNotificationTrigger\n"));

 	triggerMask=ETxAllBytes|ETxOverrun;

 	r=gChanSlaveI2c.SetNotificationTrigger(chanId,triggerMask,&status);

 	gTest(r==KErrNone);

 	// Now instruct the bus implementation to represent transmission of less than the required number of words

 	// to the bus master (Tx Overrun)

 	gTest.Printf(_L("Starting SimulateTxNWords for Tx Overrun\n"));

 	r=gChanSlaveI2c.SimulateTxNWords(busIdI2c, chanId, 10);

 	gTest(r==KErrNone);

 	//

 	// Wait for the notification

 	User::WaitForRequest(status);

 	r=status.Int();

 	if(r != KErrNone)

 		{

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

 		gTest(r==KErrNone);

 		}

 	gTest.Printf(_L("Tx Overrun test completed OK\n"));

 	// Re-set the notification trigger

 	triggerMask=ETxAllBytes|ETxUnderrun;

 	gTest.Printf(_L("Starting SetNotificationTrigger\n"));

 	r=gChanSlaveI2c.SetNotificationTrigger(chanId,triggerMask,&status);

 	gTest(r==KErrNone);

 	// Now instruct the bus implementation to represent the bus master attempting to read more words than

 	// anticipated (Tx Underrun)

 	gTest.Printf(_L("Starting SimulateTxNWords for Tx Underrun\n"));

 	r=gChanSlaveI2c.SimulateTxNWords(busIdI2c, chanId, 14);

 	gTest(r==KErrNone);

 	//

 	// Wait for the notification

 	User::WaitForRequest(status);

 	r=status.Int();

 	if(r != KErrNone)

 		{

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

 		gTest(r==KErrNone);

 		}

 	gTest.Printf(_L("Tx Underrun test completed OK\n"));

 	//

 	//		Simultaneous Rx,Tx tests

 	//

 	// For these tests, the proxy client (iic_slaveclient) will check that the expected results are witnessed

 	// in the required order, and will complete the TRequestStatus when the sequence is complete (or error occurs).

 	//

 	// Set the notification trigger for both Rx and Tx

 	triggerMask=ERxAllBytes|ETxAllBytes;

 	gTest.Printf(_L("\nStarting SetNotificationTrigger with ERxAllBytes|ETxAllBytes\n"));

 	r=gChanSlaveI2c.SetNotificationTrigger(chanId,triggerMask,&status);

 	gTest(r==KErrNone);

 	// Now instruct the bus implementation to represent receipt of the required number of words from the bus master.

 	gTest.Printf(_L("Starting SimulateRxNWords\n"));

 	r=gChanSlaveI2c.SimulateRxNWords(busIdI2c, chanId, 8);

 	gTest(r==KErrNone);

 	// Now instruct the bus implementation to represent transmission of the required number of words to the bus master.

 	gTest.Printf(_L("Starting SimulateTxNWords\n"));

 	r=gChanSlaveI2c.SimulateTxNWords(busIdI2c, chanId, 12);

 	gTest(r==KErrNone);

 	//

 	// Wait for the notification

 	User::WaitForRequest(status);

 	r=status.Int();

 	if(r != KErrNone)

 		{

 		gTest.Printf(_L("TRequestStatus value after receiving and transmitting data = %d\n"),r);

 		gTest(r==KErrNone);

 		}

 	gTest.Printf(_L("Rx, Tx test completed OK\n"));

 	//

 	// Set the notification trigger for both Rx and Tx

 	gTest.Printf(_L("Starting SetNotificationTrigger with ERxAllBytes|ETxAllBytes\n"));

 	triggerMask=ERxAllBytes|ETxAllBytes;

 	r=gChanSlaveI2c.SetNotificationTrigger(chanId,triggerMask,&status);

 	gTest(r==KErrNone);

 	// Now instruct the bus implementation to represent transmission of the required number of words to the bus master.

 	gTest.Printf(_L("Starting SimulateTxNWords\n"));

 	r=gChanSlaveI2c.SimulateTxNWords(busIdI2c, chanId, 12);

 	gTest(r==KErrNone);

 	// Now instruct the bus implementation to represent receipt of the required number of words from the bus master.

 	gTest.Printf(_L("Starting SimulateRxNWords\n"));

 	r=gChanSlaveI2c.SimulateRxNWords(busIdI2c, chanId, 8);

 	gTest(r==KErrNone);

 	//

 	// Wait for the notification

 	User::WaitForRequest(status);

 	r=status.Int();

 	if(r != KErrNone)

 		{

 		gTest.Printf(_L("TRequestStatus value after receiving and transmitting data = %d\n"),r);

 		gTest(r==KErrNone);

 		}

 	gTest.Printf(_L("Tx, Rx test completed OK\n"));

 	//

 	// Set the notification trigger for both Rx and Tx

 	gTest.Printf(_L("Starting SetNotificationTrigger with ERxAllBytes|ETxAllBytes\n"));

 	triggerMask=ERxAllBytes|ETxAllBytes;

 	r=gChanSlaveI2c.SetNotificationTrigger(chanId,triggerMask,&status);

 	gTest(r==KErrNone);

 	// Now instruct the bus implementation to represent simultaneous transmission of the required number of words (12)

 	// to the bus master and receipt of the required number of words (8) from the bus master

 	gTest.Printf(_L("Starting SimulateRxTxNWords\n"));

 	r=gChanSlaveI2c.SimulateRxTxNWords(busIdI2c, chanId, 8, 12);

 	gTest(r==KErrNone);

 	//

 	// Wait for the notification

 	User::WaitForRequest(status);

 	r=status.Int();

 	if(r != KErrNone)

 		{

 		gTest.Printf(_L("TRequestStatus value after receiving and transmitting data = %d\n"),r);

 		gTest(r==KErrNone);

 		}

 	gTest.Printf(_L("Tx with Rx test completed OK\n"));

 	// Clear the trigger mask - this is just invoking SetNotificationTrigger with a zero trigger

 	// so that no subsequent triggers are expected (and so no TRequestStatus is provided)

 	gTest.Printf(_L("Starting SetNotificationTrigger with 0\n"));

 	triggerMask=0;

 	r=gChanSlaveI2c.SetNotifNoTrigger(chanId,triggerMask);

 	gTest(r==KErrNone);

 	//

 	//		Rx Overrun and Tx Underrun when both Rx and Tx notifications are requested

 	//

 	gTest.Printf(_L("Starting RxOverrun-TxUnderrun with simultaneous Rx,Tx notification requests\n"));

 	gChanSlaveI2c.TestOverrunUnderrun(busIdI2c,chanId,status);

 	//

 	// Wait for the notification

 	User::WaitForRequest(status);

 	r=status.Int();

 	if(r != KErrNone)

 		{

 		gTest.Printf(_L("TRequestStatus value after RxOverrun-TxUnderrun with simultaneous Rx,Tx notification requests= %d\n"),r);

 		gTest(r==KErrNone);

 		}

 	gTest.Printf(_L("RxOverrun-TxUnderrun with simultaneous Rx,Tx notification requests test completed OK\n"));

 	//

 	//		Bus Error tests

 	//

 	// Simulate a bus error

 	// A bus error will cause all pending bus activity to be aborted.

 	// Request a notification, then simulate a bus error

 	triggerMask=ERxAllBytes|ETxAllBytes;

 	r=gChanSlaveI2c.SetNotificationTrigger(chanId,triggerMask,&status);

 	gTest(r==KErrNone);

 	gTest.Printf(_L("Starting SimulateBusErr\n"));

 	r = gChanSlaveI2c.SimulateBusErr(busIdI2c,chanId);

 	gTest(r==KErrNone);

 	//

 	// Wait for the notification

 	User::WaitForRequest(status);

 	r=status.Int();

 	if(r != KErrNone)

 		{

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

 		gTest(r==KErrNone);

 		}

 	gTest.Printf(_L("Bus error test completed OK\n"));

 	// Clear the trigger mask and prepare for the next test

 	// This is unnecessary if the SetNotificationTrigger for the following test

 	// is called within the timeout period applied for Client responses ...

 	// but it represents a Client ending a transaction cleanly, and so is

 	// left here as an example

 	gTest.Printf(_L("\nStarting SetNotificationTrigger with 0\n"));

 	triggerMask=0;

 	r=gChanSlaveI2c.SetNotificationTrigger(chanId,triggerMask,&status);

 	gTest(r==KErrNone);

 	// Simulate Master timeout

 	// Do this by:

 	// - Requesting a trigger for Tx

 	// - simulating the Master performing a read (ie the PSL indicates a Tx event) to start the transaction

 	// - provide a buffer for Tx, and request notification of Tx events, ie wait for Master response

 	// - block the PSL Tx notification to the PIL, so that the PIL timeout timer expires when a simulated Tx event

 	//   is next requested

 	//

 	// Indicate the test to be performed

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

 	// Register a buffer for Tx, then set the notification trigger

 	gTest.Printf(_L("RegisterTxBuffer - for Master to start the transaction\n"));

 	r=gChanSlaveI2c.RegisterTxBuffer(chanId, 4, 12, 8);

 	gTest(r==KErrNone);

 	gTest.Printf(_L("SetNotificationTrigger - for Master to start the transaction\n"));

 	triggerMask=ETxAllBytes;

 	r=gChanSlaveI2c.SetNotificationTrigger(chanId,triggerMask,&status);

 	gTest(r==KErrNone);

 	// Now instruct the bus implementation to simulate the Master reading the expected number of words

 	gTest.Printf(_L("Starting SimulateTxNWords\n"));

 	r=gChanSlaveI2c.SimulateTxNWords(busIdI2c, chanId, 12);

 	gTest(r==KErrNone);

 	// Wait for the notification

 	User::WaitForRequest(status);

 	gTest.Printf(_L("Status request completed\n"));

 	r=status.Int();

 	if(r != KErrNone)

 		{

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

 		gTest(r==KErrNone);

 		}

 	// Client is now expected to perform its part of the transaction - so pretend we need another Tx

 	//  - but block completion of the Tx so that we generate  a bus error

 	gTest.Printf(_L("SetNotificationTrigger - for second part of the transaction\n"));

 	triggerMask=ETxAllBytes;

 	r=gChanSlaveI2c.SetNotificationTrigger(chanId,triggerMask,&status);

 	gTest(r==KErrNone);

 	gTest.Printf(_L("BlockNotification\n"));

 	r=gChanSlaveI2c.BlockNotification(busIdI2c, chanId);

 	gTest(r==KErrNone);

 	// Now instruct the bus implementation to represent the bus master attempting to read the required number of words

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

 	r=gChanSlaveI2c.SimulateTxNWords(busIdI2c, chanId, 12);

 	gTest(r==KErrNone);

 	//

 	// Wait for the notification

 	User::WaitForRequest(status);

 	r=status.Int();

 	if(r != KErrNone)

 		{

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

 		gTest(r==KErrNone);

 		}

 	gTest.Printf(_L("Blocked notification test completed OK\n"));

 	// Re-set the notification trigger - for the 'blocked' Tx

 	// This is required because, in the event of a bus error, the set of requested Rx,Tx

 	// flags are cleared

 	gTest.Printf(_L("Starting SetNotificationTrigger with ETxAllBytes\n"));

 	triggerMask=ETxAllBytes;

 	r=gChanSlaveI2c.SetNotificationTrigger(chanId,triggerMask,&status);

 	gTest(r==KErrNone);

 	// Remove the block

 	gTest.Printf(_L("Starting UnblockNotification\n"));

 	r=gChanSlaveI2c.UnblockNotification(busIdI2c, chanId);

 	gTest(r==KErrNone);

 	//

 	// Wait for the notification

 	User::WaitForRequest(status);

 	r=status.Int();

 	if(r != KErrNone)

 		{

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

 		gTest(r==KErrNone);

 		}

 	gTest.Printf(_L("UnBlocked notification test completed OK\n"));

 	// Clear the trigger mask

 	gTest.Printf(_L("Starting SetNotificationTrigger with 0\n"));

 	triggerMask=0;

 	r=gChanSlaveI2c.SetNotificationTrigger(chanId,triggerMask,&status);

 	gTest(r==KErrNone);

 	// Release the channel

 	r = gChanSlaveI2c.ReleaseChannel( chanId );

 	gTest(r==KErrNone);

 	delete i2cBuf;

 #else

 	gTest.Printf(_L("\nSlaveRxTxNotificationTests only supported when SLAVE_MODE is defined\n"));

 #endif

 	return r;

 	}

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

 //! @SYMTestCaseID      KBASE-T_IIC-2404

 //! @SYMTestType        UT

 //! @SYMPREQ            PREQ2128,2129

 //! @SYMTestCaseDesc    This test case tests that MasterSlave channels can only be used in one mode at a time, and that

 //!						if captured for Slave operation or with transactions queued for Master operation the channel can

 //!						not be de-registered.

 //! @SYMTestActions     0) 	Capture the channel for Slave operation. Attempt to synchronously queue a transaction

 //!							on the channel. Attempt to asynchronously queue a transaction on the channel. Attempt

 //!						    to de-register the channel.Release the Slave channel

 //!

 //!						1) Use controlio to block completion of queued transactions. Request asynchronous queue

 //!						   transaction. Attempt to capture the channel for Slave operation. Attempt to de-register

 //!						   the channel. Unblock completion of transactions and wait for the TRequestStatus for the

 //!						   transaction to be completed.

 //!

 //! @SYMTestExpectedResults 0) 	Once captured for Slave operation, attempts to queue a transaction or de-register the channel

 //!							    return KErrInUse, exits otherwise.

 //!						1) With a transaction queued, attempt to capture the channel returns KErrInUse, exits otherwise.

 //!						   Attempt to de-register channel returns KErrInUse, exits otherwise. The TRequestStatus should

 //!						   be set to KErrTimedOut, exits otherwise.

 //!

 //!

 //! @SYMTestPriority        High

 //! @SYMTestStatus          Implemented

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

 LOCAL_C TInt MasterSlaveAcquisitionTests()

 //

 //	Test to check that:

 //	(1) A Master-Slave channel that has been captured for use in Slave mode will not allow requests for

 //		queing transactions to be accepted

 //	(2) A Master-Slave channel that has been captured for use in Slave mode can not be de-registered

 //	(3) A Master-Slave channel that has one or more transactions queued in its Master channel transaction queue

 //		can not be captured for use in Slave Made

 //	(4) A Master-Slave channel that has one or more transactions queued in its Master channel transaction queue

 //		can not be de-registered

 //

 	{

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

 	TInt r=KErrNone;

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

 	//	Create a Master-Slave channel

 	RBusDevIicClient chanMasterSlaveI2c;

 	TBufC<18> proxyName;

 	if(!aStandAloneChan)

 		proxyName = KIicProxyFileNameRoot;

 	else

 		proxyName = KIicProxyFileNameRootCtrlLess;

 	r = chanMasterSlaveI2c.Open(proxyName);

 	gTest(r==KErrNone);

 	r = chanMasterSlaveI2c.InitSlaveClient();	// Initialise callback used for Slave processing

 	gTest(r==KErrNone);

 	//

 	//	Capture the channel for Slave operation

 	//  Attempt to synchronously queue a transaction on the channel - expect KErrInUse as a response

 	//  Attempt to asynchronously queue a transaction on the channel - expect KErrInUse as a response

 	//  Attempt to de-register the channel - expect KErrInUse as a response

 	//  Release the Slave channel

 	//

 	// Create a I2C configuration buffer and the configuration data for use in capturing gChanSlaveI2c

 	TUint32 busIdI2c = 0;

 	TConfigI2cBufV01* i2cBuf=NULL;

 	r=CreateSlaveChanI2cConfig(i2cBuf, busIdI2c, 12);	// 12 is the MasterSlave channel number

 	gTest(r==KErrNone);

 	TInt chanId;

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

 	r = chanMasterSlaveI2c.CaptureChannel(busIdI2c, i2cBuf, chanId );

 	gTest.Printf(_L("Synchronous CaptureChannel returned = %d, chanId=0x%x\n"),r,chanId);

 	gTest(r==KErrNone);

 	//

 	_LIT(halfDuplexText,"Half Duplex Text");

 	TBuf8<17> halfDuplexBuf_8;

 	halfDuplexBuf_8.Copy(halfDuplexText);

 	TUsideTferDesc* tfer = NULL;

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

 	if(r!=KErrNone)

 		return r;

 	if(tfer==NULL)

 		return KErrGeneral;

 	//

 	TUsideTracnDesc* tracn = NULL;

 	r = CreateSingleUserSideTransaction(tracn, EI2c, i2cBuf, tfer, NULL, 0, NULL, NULL);

 	if(r!=KErrNone)

 		return r;

 	if(tracn==NULL)

 		return KErrGeneral;

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

 	r = chanMasterSlaveI2c.QueueTransaction(busIdI2c, tracn);

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

 	gTest(r==KErrInUse);

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

 	TRequestStatus status;

 	chanMasterSlaveI2c.QueueTransaction(status, busIdI2c, tracn);

 	User::WaitForRequest(status);

 	if(status != KErrInUse)

 		{

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

 		gTest(r==KErrInUse);

 		}

 //

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

 //	// So the RegisterChan and DeRegisterChan are not needed.

 	if(aStandAloneChan == 0)

 		{

 		gTest.Printf(_L("\nStarting deregistration of captured channel\n"));

 		r = chanMasterSlaveI2c.DeRegisterChan(busIdI2c);

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

 		gTest(r==KErrInUse);

 		}

 	gTest.Printf(_L("\nInvoke ReleaseChannel for chanId=0x%x \n"),chanId);

 	r = chanMasterSlaveI2c.ReleaseChannel( chanId );

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

 	gTest(r==KErrNone);

 	//

 	//	Use ControlIO/StaticExtension to block transactions on the Master Channel

 	//  Queue an asynchronous transaction on the channel

 	//  Attempt to capture the channel for Slave operation - expect KErrInUse as a response

 	//  Attempt to de-register the channel - expect KErrInUse as a response

 	//  Unblock the channel

 	//  Check for (timed out) completion of the transaction

 	//

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

 	r = chanMasterSlaveI2c.BlockReqCompletion(busIdI2c);

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

 	//

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

 	chanMasterSlaveI2c.QueueTransaction(status, busIdI2c, tracn);

 	//

 	User::After(50000);

 	//

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

 	r = chanMasterSlaveI2c.CaptureChannel(busIdI2c, i2cBuf, chanId );

 	gTest.Printf(_L("Synchronous CaptureChannel returned = %d, chanId=0x%x\n"),r,chanId);

 	gTest(r==KErrInUse);

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

 	// So the RegisterChan and DeRegisterChan are not needed.

 	if(aStandAloneChan == 0)

 		{

 		gTest.Printf(_L("\nStarting deregistration of channel\n"));

 		r = chanMasterSlaveI2c.DeRegisterChan(busIdI2c);

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

 		gTest(r==KErrInUse);

 		}

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

 	r = chanMasterSlaveI2c.UnblockReqCompletion(busIdI2c);

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

 	//

 	User::After(50000);

 	//

 	User::WaitForRequest(status);

 	r=status.Int();

 	if(r != KErrTimedOut)

 		{

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

 		gTest(r==KErrTimedOut);

 		}

 	r=KErrNone; // Ensure error code is not propagated

 	delete i2cBuf;

 	delete tfer;

 	delete tracn;

 	chanMasterSlaveI2c.Close();

 #else

 	gTest.Printf(_L("\nMasterSlaveAcquisitionTests only supported when both MASTER_MODE and SLAVE_MODE are defined\n"));

 #endif

 	return r;

 	}

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

 //! @SYMTestCaseID      KBASE-T_IIC-2404

 //! @SYMTestType        UT

 //! @SYMDEF             DEF141732

 //! @SYMTestCaseDesc    This test case tests the inline functions of DIicBusChannel interface.

 //! @SYMTestActions     Call Kernel-side proxy client function to perform interface tests.

 //! @SYMTestExpectedResults Kernel-side proxy client should return with KErrNone.

 //! @SYMTestPriority        Medium

 //! @SYMTestStatus          Implemented

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

 LOCAL_C TInt IicInterfaceInlineTests()

     {

     if(aStandAloneChan == 1)

         {

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

         TInt r=KErrNone;

         r = gChanMasterSpi.TestIiicChannelInlineFunc();

         return r;  

         }

     else

         {

         gTest.Printf(_L("\nIicInterfaceInlineTests can only be run in Standalone mode\n"));

         return KErrNone;

         }

     }

 LOCAL_C TInt RunTests()

 //

 //	Utility method to invoke the separate tests

 //

 	{

 	TInt r =KErrNone;

 	r = IicInterfaceInlineTests();

     if(r!=KErrNone)

         return r;

 	r = MasterBasicTests();

 	if(r!=KErrNone)

 		return r;

 	r = SlaveRxTxNotificationTests();

 	if(r!=KErrNone)

 		return r;

 	r = SlaveChannelCaptureReleaseTests();

 	if(r!=KErrNone)

 		return r;

 	r = MasterExtTests(KTransactionWithPreamble);

 	if(r!=KErrNone)

 		return r;

 	r = MasterExtTests(KTransactionWithMultiTransc);

 	if(r!=KErrNone)

 		return r;

 	r = MasterExtTests(KTransactionWithMultiTransc|KTransactionWithPreamble);

 	if(r!=KErrNone)

 		return r;

 	r = MasterTransactionTests();

 	if(r!=KErrNone)

 		return r;

 	r = MasterSlaveAcquisitionTests();

 	if(r!=KErrNone)

 		return r;

 	return KErrNone;

 	}

 GLDEF_C TInt E32Main()

 //

 // Main

 //

     {

 	gTest.Title();

 	gTest.Start(_L("Test IIC API\n"));

 	TInt r = KErrNone;

     // Turn off lazy dll unloading

     RLoader l;

     gTest(l.Connect()==KErrNone);

     gTest(l.CancelLazyDllUnload()==KErrNone);

     l.Close();

 #ifdef IIC_SIMULATED_PSL

 	gTest.Next(_L("Start the IIC with controller test\n"));

 	aStandAloneChan = 0;

 	gTest.Next(_L("Load Simulated IIC PSL bus driver"));

 	r = User::LoadPhysicalDevice(KIicPslFileName);

 	gTest.Printf(_L("return value r=%d"),r);

 	gTest(r==KErrNone || r==KErrAlreadyExists);

 	gTest.Next(_L("Load Simulated PSL SPI bus driver"));

 	r = User::LoadPhysicalDevice(KSpiFileName);

 	gTest.Printf(_L("return value r=%d"),r);

 	gTest(r==KErrNone || r==KErrAlreadyExists);

 	gTest.Next(_L("Load Simulated PSL I2C bus driver"));

 	r = User::LoadPhysicalDevice(KI2cFileName);

 	gTest.Printf(_L("return value r=%d"),r);

 	gTest(r==KErrNone || r==KErrAlreadyExists);

 	gTest.Next(_L("Load kernel-side proxy IIC client"));

 	r = User::LoadLogicalDevice(KIicProxyFileName);

 	gTest(r==KErrNone || r==KErrAlreadyExists);

 	gTest.Next(_L("Load kernel-side proxy IIC slave client"));

 	r = User::LoadLogicalDevice(KIicProxySlaveFileName);

 	gTest(r==KErrNone || r==KErrAlreadyExists);

 	__KHEAP_MARK;

 	// First ascertain what bus options are available.

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

 	// Open a Master SPI channel to the kernel side proxy

 	TBufC<30> proxyName(KIicProxyFileNameRoot);

 	r = gChanMasterSpi.Open(proxyName);

 	gTest(r==KErrNone);

 	// 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 numer 11 if built with both MASTER_MODE and SLAVE_MODE

 	// Open a Master I2C channel to the kernel side proxy

 	r = gChanMasterI2c.Open(proxyName);

 	gTest(r==KErrNone);

 	TBufC<15> proxySlaveName(KIicProxySlaveFileNameRoot);

 	r = gChanSlaveI2c.Open(proxySlaveName);

 	gTest(r==KErrNone);

 	r = gChanSlaveI2c.InitSlaveClient();

 	gTest(r==KErrNone);

 	// Instigate tests

 	r = RunTests();

 	gTest(r==KErrNone);

 	gTest.Printf(_L("Tests completed OK, about to close channel\n"));

 	gChanMasterSpi.Close();

 	gChanMasterI2c.Close();

 	gChanSlaveI2c.Close();

 	UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, 0, 0);

 	__KHEAP_MARKEND;

 	gTest.Next(_L("Free kernel-side proxy IIC client"));

 	TInt err = User::FreeLogicalDevice(KIicProxyFileNameRoot);

 	gTest(err==KErrNone || err==KErrAlreadyExists);

 	gTest.Next(_L("Free kernel-side proxy IIC slave client"));

 	err = User::FreeLogicalDevice(KIicProxySlaveFileNameRoot);

 	gTest(err==KErrNone || err==KErrAlreadyExists);

 	gTest.Next(_L("Free Simulated PSL I2C bus driver"));

 	err = User::FreePhysicalDevice(KI2cFileName);

 	gTest(err==KErrNone);

 	gTest.Next(_L("Free Simulated PSL SPI bus driver"));

 	err = User::FreePhysicalDevice(KSpiFileName);

 	gTest(err==KErrNone);

 	gTest.Next(_L("Free Simulated IIC PSL bus driver"));

 	err = User::FreePhysicalDevice(KIicPslFileNameRoot);

 	gTest(err==KErrNone);

 	gTest.Next(_L("Start the controller-less IIC test\n"));

 	aStandAloneChan = 1;

 	gTest.Next(_L("Load Simulated PSL SPI bus driver"));

 	r = User::LoadPhysicalDevice(KSpiFileNameCtrlLess);

 	gTest.Printf(_L("return value r=%d"),r);

 	gTest(r==KErrNone || r==KErrAlreadyExists);

 	gTest.Next(_L("Load Simulated PSL I2C bus driver"));

 	r = User::LoadPhysicalDevice(KI2cFileNameCtrlLess);

 	gTest.Printf(_L("return value r=%d"),r);

 	gTest(r==KErrNone || r==KErrAlreadyExists);

 	gTest.Next(_L("Load kernel-side proxy IIC client"));

 	r = User::LoadLogicalDevice(KIicProxyFileNameCtrlLess);

 	gTest(r==KErrNone || r==KErrAlreadyExists);

 	gTest.Next(_L("Load kernel-side proxy IIC slave client"));

 	r = User::LoadLogicalDevice(KIicProxySlaveFileNameCtrlLess);

 	gTest(r==KErrNone || r==KErrAlreadyExists);

 	// First ascertain what bus options are available.

 	__KHEAP_MARK;

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

 	// Open a Master SPI channel to the kernel side proxy

 	TBufC<30> proxyNameCtrlLess(KIicProxyFileNameRootCtrlLess);

 	r = gChanMasterSpi.Open(proxyNameCtrlLess);

 	gTest(r==KErrNone);

 	// 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 numer 11 if built with both MASTER_MODE and SLAVE_MODE

 	// Open a Master I2C channel to the kernel side proxy

 	r = gChanMasterI2c.Open(proxyNameCtrlLess);

 	gTest(r==KErrNone);

 	TBufC<35> proxySlaveNameCtrlLess(KIicProxySlaveFileNameRootCtrlLess);

 	r = gChanSlaveI2c.Open(proxySlaveNameCtrlLess);

 	gTest(r==KErrNone);

 	r = gChanSlaveI2c.InitSlaveClient();

 	gTest(r==KErrNone);

 	// Instigate tests

 	r = RunTests();

 	gTest(r==KErrNone);

 	gTest.Printf(_L("Tests completed OK, about to close channel\n"));

 	gChanMasterSpi.Close();

 	gChanMasterI2c.Close();

 	gChanSlaveI2c.Close();

 	UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, 0, 0);

 	__KHEAP_MARKEND;

 	gTest.Next(_L("Free kernel-side proxy IIC client"));

 	err = User::FreeLogicalDevice(KIicProxyFileNameRootCtrlLess);

 	gTest(err==KErrNone || err==KErrAlreadyExists);

 	gTest.Next(_L("Free kernel-side proxy IIC slave client"));

 	err = User::FreeLogicalDevice(KIicProxySlaveFileNameRootCtrlLess);

 	gTest(err==KErrNone || err==KErrAlreadyExists);

 	gTest.Next(_L("Free Simulated PSL I2C bus driver"));

 	err = User::FreePhysicalDevice(KI2cFileNameCtrlLess);

 	gTest(err==KErrNone);

 	gTest.Next(_L("Free Simulated PSL SPI bus driver"));

 	err = User::FreePhysicalDevice(KSpiFileNameCtrlLess);

 	gTest(err==KErrNone);

 #else

 	gTest.Printf(_L("Don't do the test if it is not IIC_SIMULATED_PSL"));

 #endif

 	gTest.End();

 	return r;

     }