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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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\dma\dma_api_tests.cpp

// 

// Overview:

//  This file contains API tests for the new DMA framework

//

#define __E32TEST_EXTENSION__

#include "d_dma2.h"

#include "u32std.h"

#include "t_dma2.h"

#include "cap_reqs.h"

#include <e32test.h>

#include <e32debug.h>

#include <e32svr.h>

static RTest test(_L("DMA Test Framework API"));

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

//! @SYMTestCaseID      KBASE-DMA-2564

//! @SYMTestType        CIT

//! @SYMPREQ            REQ

//! @SYMTestCaseDesc    This test checks the correct behaviour of Open API in the new DMA framework

//!

//! @SYMTestActions     

//!						1.  Open a DMA channel

//!						2.	Verify that channel is really open.

//!

//! @SYMTestExpectedResults 

//!						1.  DMA channel opens and KErrNone returned

//!						2.  Call to ChannelIsOpened() return as ETrue.

//!

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

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

void test_open_api()

{

	//TO DO : Expose TInt Open(const SCreateInfo& aInfo, TDmaChannel*& aChannel)

	//TO DO : Implement more test cases

	test.Start(_L("*** Testing Open() API  ***"));

	test.Next(_L("Open session"));

	RDmaSession session;

	TInt r = session.Open();

	test_KErrNone(r);

	TUint channelCookie_open_api=0;

	test.Next(_L("Open DMA Channel"));

	channelCookie_open_api=0;

	r = session.ChannelOpen(16, channelCookie_open_api);

	test.Printf(_L("cookie recieved = 0x%08x\n"), channelCookie_open_api);

	test_KErrNone(r);

	//Check if channel is open

	// test.Printf(_L("Verify that the specified DMA channel is opened\n"));	

	// TBool channelOpened;

	// TBool channelNotOpened = EFalse;

	// r = session.ChannelIsOpened(channelCookie_open_api,  channelOpened);

	// test_KErrNone(r);	

 	// TEST_ASSERT(channelOpened != channelNotOpened)

	//close channel

	test.Next(_L("Channel close"));

	r = session.ChannelClose(channelCookie_open_api);

	test_KErrNone(r);

	RTest::CloseHandleAndWaitForDestruction(session);

	test.End();

}

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

//! @SYMTestCaseID      KBASE-DMA-2568

//! @SYMTestType        CIT

//! @SYMPREQ            REQ

//! @SYMTestCaseDesc    This test checks the correct behaviour of Close API in the new DMA framework

//!

//! @SYMTestActions     

//!						1.  Open a DMA channel

//!						2.	Open DMA Channel again

//!						3	Close the DMA channel.

//!						4	Open DMA channel to verify that the DMA channel closed.

//!						5.	Open DMA channel again.

//!						6.	Queue a request on the channel.

//!						7.	Close DMA channel while request is still queued on it.

//!

//! @SYMTestExpectedResults 

//!						1.  DMA channel opens and KErrNone returned.

//!						2.	DMA Framework returns KErrInUse as channel is already open.					

//!						3.	DMA channel closes and KErrNone returned.

//!						4.	DMA channel opens and KErrNone returned.

//!						5.	DMA Framework returns KErrInUse as channel is already open.

//!						6.	DMA request queued and KErrNone returned.

//!						7.	DMA channel closes and DMA framework flags an error.

//!							

//!

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

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

void test_close_api()

{

	test.Start(_L("*** Testing Close() API  ***"));

	test.Next(_L("Open session"));

	RDmaSession session;

	TInt r = session.Open();

	test_KErrNone(r);

	const TInt size = 64 * KKilo;

	TUint reqCookieNewStyle_close_api=0;	

	TUint channelCookie_close_api=0;

	test.Next(_L("Open a single DMA channel"));

	r = session.ChannelOpen(16, channelCookie_close_api);

	test.Printf(_L("cookie recieved = 0x%08x\n"), channelCookie_close_api);

	test_KErrNone(r);

	// test.Next(_L("Open DMA channel again"));

	// TUint channelCookie_close_api_1=0;

	// r = session.ChannelOpen(16, channelCookie_close_api_1);

	// test.Printf(_L("Verify that DMA channel is already opened\n"));

	// test_Equal(KErrInUse,r); 

	test.Next(_L("Close the DMA channel"));

	r = session.ChannelClose(channelCookie_close_api);

	test_KErrNone(r);

	test.Next(_L("Open DMA channel again"));

	r = session.ChannelOpen(16, channelCookie_close_api);

	test.Printf(_L("Verify that DMA channel was closed\n"));

	test_KErrNone(r); 

	//Fails if a request is created and cancel

	test.Next(_L("Queue a request on the channel"));

  	r = session.RequestCreateNew(channelCookie_close_api, reqCookieNewStyle_close_api); //Create Dma request (with new-style callback)

  	test.Printf(_L("cookie recieved for open channel = 0x%08x\n"), reqCookieNewStyle_close_api);

  	test_KErrNone(r);

  	TDmaTransferArgs transferArgs_close_api;

  	transferArgs_close_api.iSrcConfig.iAddr = 0;

  	transferArgs_close_api.iDstConfig.iAddr = size;

  	transferArgs_close_api.iSrcConfig.iFlags = KDmaMemAddr;

  	transferArgs_close_api.iDstConfig.iFlags = KDmaMemAddr;

  	transferArgs_close_api.iTransferCount = size;

  	r = session.FragmentRequest(reqCookieNewStyle_close_api, transferArgs_close_api);

  	test_KErrNone(r);

  	test.Next(_L("Queue DMA Request"));

  	TCallbackRecord record_close_api;

  	r = session.QueueRequest(reqCookieNewStyle_close_api, &record_close_api);

  	test_KErrNone(r);

	test.Next(_L("Destroy Dma request"));

	r = session.RequestDestroy(reqCookieNewStyle_close_api);

	test_KErrNone(r);

	test.Next(_L("Close the DMA channel"));

	r = session.ChannelClose(channelCookie_close_api);

	test_KErrNone(r);

	test.End();

	RTest::CloseHandleAndWaitForDestruction(session);

}

void RDmaSession::ApiTest()

	{

    test_open_api();     // Verify that Open() opens a DMA channel

    test_close_api();    // Verify that Close() closes a DMA channel

	}

void ApiTests()

	{

	test.Next(_L("Running framework API tests"));

	RDmaSession::ApiTest();	

	test.Close();

	}