/*

* Copyright (c) 2002 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:  MPXActiveTaskQueue testing implementation

*

*/

#include <s32mem.h>

#include "commontestclass.h"

// Begin CMPXActiveTaskQueue testing implementation (mpxtaskqueue.h)=======================================

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

// CCommonTestClass::CreateCMPXActiveTaskQueueL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::CreateCMPXActiveTaskQueueL()

    {

	FTRACE(FPrint(_L("CCommonTestClass::CreateCMPXActiveTaskQueueL testing CMPXActiveTaskQueue::NewL() begin")));

    iLog->Log(_L("CCommonTestClass::CreateCMPXActiveTaskQueueL testing CMPXActiveTaskQueue::NewL() begin"));

    TInt err = KErrNone;

    CMPXActiveTaskQueue* taskQueue = NULL;

    taskQueue = CMPXActiveTaskQueue::NewL();

    if ( taskQueue == NULL)

        {

        err = KErrNotFound;

        }

    delete taskQueue;

	FTRACE(FPrint(_L("CCommonTestClass::CreateCMPXActiveTaskQueueL testing CMPXActiveTaskQueue::NewL() end err=%d"), err));

    iLog->Log(_L("CCommonTestClass::CreateCMPXActiveTaskQueueL testing CMPXActiveTaskQueue::NewL() end err=%d"), err);

	return err;

    }

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

// CCommonTestClass::CancelRequestsCMPXActiveTaskQueueL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::CancelRequestsCMPXActiveTaskQueueL()

    {

	FTRACE(FPrint(_L("CCommonTestClass::CancelRequestsCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CancelRequests begin")));

    iLog->Log(_L("CCommonTestClass::CancelRequestsCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CancelRequests begin"));

    TInt err = KErrNone;

    CMPXActiveTaskQueue* taskQueue = NULL;

    taskQueue = CMPXActiveTaskQueue::NewL();

    taskQueue->CancelRequests();

    delete taskQueue;

	FTRACE(FPrint(_L("CCommonTestClass::CancelRequestsCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CancelRequests end=%d"), err));

    iLog->Log(_L("CCommonTestClass::CancelRequestsCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CancelRequests end=%d"), err);

	return err;

    }

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

// CCommonTestClass::AddTaskCMPXActiveTaskQueueL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::AddTaskCMPXActiveTaskQueueL()

    {

	FTRACE(FPrint(_L("CCommonTestClass::AddTaskCMPXActiveTaskQueueL testing CMPXActiveTaskQueue::AddTaskL begin")));

    iLog->Log(_L("CCommonTestClass::AddTaskCMPXActiveTaskQueueL testing CMPXActiveTaskQueue::AddTaskL begin"));

    TInt err = KErrNone;

    CMPXActiveTaskQueue* taskQueue = NULL;

    taskQueue = CMPXActiveTaskQueue::NewL();

    TInt task(0); //ETaskNone

    CBufBase* taskParam(NULL);

    taskQueue->AddTaskL( task,

                          NULL,   // callback when task completed

                          NULL,        // task queue observer

                          0,           // Integer paramter, not used

                          taskParam,   // task queue assumes ownership of taskParam

                          NULL,        // Ptr data 

                          NULL );   

    taskQueue->CancelRequests();

    delete taskQueue;

	FTRACE(FPrint(_L("CCommonTestClass::AddTaskCMPXActiveTaskQueueL testing CMPXActiveTaskQueue::AddTaskL end err=%d"), err));

    iLog->Log(_L("CCommonTestClass::AddTaskCMPXActiveTaskQueueL testing CMPXActiveTaskQueue::AddTaskL end err=%d"), err);

	return err;

    }

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

// CCommonTestClass::CompleteTaskCMPXActiveTaskQueueL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::CompleteTaskCMPXActiveTaskQueueL()

    {

	FTRACE(FPrint(_L("CCommonTestClass::CompleteTaskCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CompleteTask begin")));

    iLog->Log(_L("CCommonTestClass::CompleteTaskCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CompleteTask begin"));

    TInt err = KErrNone;

    CMPXActiveTaskQueue* taskQueue = NULL;

    taskQueue = CMPXActiveTaskQueue::NewL();

    TInt task(0); //ETaskNone

    CBufBase* taskParam(NULL);

    taskQueue->AddTaskL( task,

                          NULL,   // callback when task completed

                          NULL,        // task queue observer

                          0,           // Integer paramter, not used

                          taskParam,   // task queue assumes ownership of taskParam

                          NULL,        // Ptr data 

                          NULL );   

    taskQueue->CompleteTask();

    taskQueue->CancelRequests();

    delete taskQueue;

	FTRACE(FPrint(_L("CCommonTestClass::CompleteTaskCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CompleteTask end=%d"), err));

    iLog->Log(_L("CCommonTestClass::CompleteTaskCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CompleteTask end=%d"), err);

	return err;

    }

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

// CCommonTestClass::CompleteAllTasksCMPXActiveTaskQueueL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::CompleteAllTasksCMPXActiveTaskQueueL()

    {

	FTRACE(FPrint(_L("CCommonTestClass::CompleteAllTasksCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CompleteTask begin")));

    iLog->Log(_L("CCommonTestClass::CompleteAllTasksCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CompleteTask begin"));

    TInt err = KErrNone;

    CMPXActiveTaskQueue* taskQueue = NULL;

    taskQueue = CMPXActiveTaskQueue::NewL();

    TInt task(0); //ETaskNone

    CBufBase* taskParam(NULL);

    taskQueue->AddTaskL( task,

                          NULL,   // callback when task completed

                          NULL,        // task queue observer

                          0,           // Integer paramter, not used

                          taskParam,   // task queue assumes ownership of taskParam

                          NULL,        // Ptr data 

                          NULL );   

    taskQueue->CompleteTask();

    taskQueue->CompleteAllTasks( 0 );

    taskQueue->CancelRequests();

    delete taskQueue;

	FTRACE(FPrint(_L("CCommonTestClass::CompleteAllTasksCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CompleteTask end=%d"), err));

    iLog->Log(_L("CCommonTestClass::CompleteAllTasksCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CompleteTask end=%d"), err);

	return err;

    }

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

// CCommonTestClass::IsEmptyCMPXTaskQueueL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::IsEmptyCMPXTaskQueueL()

    {

	FTRACE(FPrint(_L("CCommonTestClass::IsEmptyCMPXTaskQueueL testing CMPXTaskQueueL::IsEmpty begin")));

    iLog->Log(_L("CCommonTestClass::IsEmptyCMPXTaskQueueL testing CMPXTaskQueueL::IsEmpty begin"));

    TInt err = KErrNone;

    CMPXTaskQueue* taskQueue = NULL;

    taskQueue = CMPXTaskQueue::NewL();

    taskQueue->IsEmpty();

    delete taskQueue;

	FTRACE(FPrint(_L("CCommonTestClass::IsEmptyCMPXTaskQueueL testing CMPXTaskQueueL::IsEmpty end=%d"), err));

    iLog->Log(_L("CCommonTestClass::IsEmptyCMPXTaskQueueL testing CMPXTaskQueueL::IsEmpty end=%d"), err);

	return err;

    }

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

// CCommonTestClass::AddTaskCMPXTaskQueueL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::AddTaskCMPXTaskQueueL()

    {

	FTRACE(FPrint(_L("CCommonTestClass::AddTaskCMPXTaskQueueL testing CMPXTaskQueue::AddTaskL begin")));

    iLog->Log(_L("CCommonTestClass::AddTaskCMPXTaskQueueL testing CMPXTaskQueue::AddTaskL begin"));

    TInt err = KErrNone;

    CMPXTaskQueue* taskQueue = CMPXTaskQueue::NewL();

    TInt task(0); //ETaskNone

    CBufBase* taskParam(NULL);

    taskQueue->AddTaskL( task,

                          NULL,   // callback when task completed

                          NULL,        // task queue observer

                          0,           // Integer paramter, not used

                          taskParam,   // task queue assumes ownership of taskParam

                          NULL,        // Ptr data 

                          NULL );   

    taskQueue->Reset();

    delete taskQueue;

	FTRACE(FPrint(_L("CCommonTestClass::AddTaskCMPXTaskQueueL testing CMPXTaskQueue::AddTaskL end err=%d"), err));

    iLog->Log(_L("CCommonTestClass::AddTaskCMPXTaskQueueL testing CMPXTaskQueue::AddTaskL end err=%d"), err);

	return err;

    }

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

// CCommonTestClass::RemoveTaskCMPXTaskQueueL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::RemoveTaskCMPXTaskQueueL()

    {

	FTRACE(FPrint(_L("CCommonTestClass::RemoveTaskCMPXTaskQueueL testing CMPXTaskQueue::RemoveTask begin")));

    iLog->Log(_L("CCommonTestClass::RemoveTaskCMPXTaskQueueL testing CMPXTaskQueue::RemoveTask begin"));

    TInt err = KErrNone;

    CMPXTaskQueue* taskQueue = CMPXTaskQueue::NewL();

    TInt task(0); //ETaskNone

    CBufBase* taskParam(NULL);

    taskQueue->AddTaskL( task,

                          this,        // task queue observer

                          0,           // Integer paramter, not used

                          taskParam,   // task queue assumes ownership of taskParam

                          NULL,        // Ptr data 

                          NULL,

                          NULL );   

    taskQueue->RemoveTask(this);

    delete taskQueue;

	FTRACE(FPrint(_L("CCommonTestClass::RemoveTaskCMPXTaskQueueL testing CMPXTaskQueue::RemoveTask end err=%d"), err));

    iLog->Log(_L("CCommonTestClass::RemoveTaskCMPXTaskQueueL testing CMPXTaskQueue::RemoveTask end err=%d"), err);

	return err;

    }

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

// CCommonTestClass::CallbackCMPXTaskQueueL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::CallbackCMPXTaskQueueL()

    {

	FTRACE(FPrint(_L("CCommonTestClass::CallbackCMPXTaskQueueL testing CMPXTaskQueue::Callback begin")));

    iLog->Log(_L("CCommonTestClass::CallbackCMPXTaskQueueL testing CMPXTaskQueue::Callback begin"));

    TInt err = KErrNone;

    CMPXTaskQueue* taskQueue = CMPXTaskQueue::NewL();

    TInt task(0); //ETaskNone

    CBufBase* taskParam(NULL);

    taskQueue->AddTaskL( task,

                          this,        // task queue observer

                          0,           // Integer paramter, not used

                          taskParam,   // task queue assumes ownership of taskParam

                          NULL,        // Ptr data 

                          NULL,

                          NULL );   

    taskQueue->Callback();

    taskQueue->RemoveTask(this);

    delete taskQueue;

	FTRACE(FPrint(_L("CCommonTestClass::CallbackCMPXTaskQueueL testing CMPXTaskQueue::Callback end err=%d"), err));

    iLog->Log(_L("CCommonTestClass::CallbackCMPXTaskQueueL testing CMPXTaskQueue::Callback end err=%d"), err);

	return err;

    }

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

// CCommonTestClass::ParamCMPXTaskQueueL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::ParamCMPXTaskQueueL()

    {

	FTRACE(FPrint(_L("CCommonTestClass::ParamCMPXTaskQueueL testing CMPXTaskQueue::Param begin")));

    iLog->Log(_L("CCommonTestClass::ParamCMPXTaskQueueL testing CMPXTaskQueue::Param begin"));

    TInt err = KErrNone;

    CMPXTaskQueue* taskQueue = CMPXTaskQueue::NewL();

    TInt task(0); //ETaskNone

    CBufBase* taskParam(NULL);

    taskQueue->AddTaskL( task,

                          this,        // task queue observer

                          0,           // Integer paramter, not used

                          taskParam,   // task queue assumes ownership of taskParam

                          NULL,        // Ptr data 

                          NULL,

                          NULL );   

    taskQueue->Param();

    taskQueue->RemoveTask(this);

    delete taskQueue;

	FTRACE(FPrint(_L("CCommonTestClass::ParamCMPXTaskQueueL testing CMPXTaskQueue::Param end err=%d"), err));

    iLog->Log(_L("CCommonTestClass::ParamCMPXTaskQueueL testing CMPXTaskQueue::Param end err=%d"), err);

	return err;

    }

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

// CCommonTestClass::PtrDataCMPXTaskQueueL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::PtrDataCMPXTaskQueueL()

    {

	FTRACE(FPrint(_L("CCommonTestClass::ParamCMPXTaskQueueL testing CMPXTaskQueue::PtrData begin")));

    iLog->Log(_L("CCommonTestClass::ParamCMPXTaskQueueL testing CMPXTaskQueue::PtrData begin"));

    TInt err = KErrNone;

    CMPXTaskQueue* taskQueue = CMPXTaskQueue::NewL();

    TInt task(0); //ETaskNone

    CBufBase* taskParam(NULL);

    taskQueue->AddTaskL( task,

                          this,        // task queue observer

                          0,           // Integer paramter, not used

                          taskParam,   // task queue assumes ownership of taskParam

                          NULL,        // Ptr data 

                          NULL,

                          NULL );   

    taskQueue->PtrData();

    taskQueue->RemoveTask(this);

    delete taskQueue;

	FTRACE(FPrint(_L("CCommonTestClass::ParamCMPXTaskQueueL testing CMPXTaskQueue::PtrData end err=%d"), err));

    iLog->Log(_L("CCommonTestClass::ParamCMPXTaskQueueL testing CMPXTaskQueue::PtrData end err=%d"), err);

	return err;

    }

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

// CCommonTestClass::BufDataCMPXTaskQueueL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::BufDataCMPXTaskQueueL()

    {

	FTRACE(FPrint(_L("CCommonTestClass::BufDataCMPXTaskQueueL testing CMPXTaskQueue::BufData begin")));

    iLog->Log(_L("CCommonTestClass::BufDataCMPXTaskQueueL testing CMPXTaskQueue::BufData begin"));

    TInt err = KErrNone;

    CMPXTaskQueue* taskQueue = CMPXTaskQueue::NewL();

    TInt task(0); //ETaskNone

    CBufBase* taskParam(NULL);

    taskQueue->AddTaskL( task,

                          this,        // task queue observer

                          0,           // Integer paramter, not used

                          taskParam,   // task queue assumes ownership of taskParam

                          NULL,        // Ptr data 

                          NULL,

                          NULL );   

    taskQueue->BufData();

    taskQueue->RemoveTask(this);

    delete taskQueue;

	FTRACE(FPrint(_L("CCommonTestClass::BufDataCMPXTaskQueueL testing CMPXTaskQueue::BufData end err=%d"), err));

    iLog->Log(_L("CCommonTestClass::BufDataCMPXTaskQueueL testing CMPXTaskQueue::BufData end err=%d"), err);

	return err;

    }

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

// CCommonTestClass::RemoveTask2CMPXTaskQueueL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::RemoveTask2CMPXTaskQueueL()

    {

	FTRACE(FPrint(_L("CCommonTestClass::RemoveTask2CMPXTaskQueueL testing CMPXTaskQueue::RemoveTask begin")));

    iLog->Log(_L("CCommonTestClass::RemoveTask2CMPXTaskQueueL testing CMPXTaskQueue::RemoveTask begin"));

    TInt err = KErrNone;

    CMPXTaskQueue* taskQueue = CMPXTaskQueue::NewL();

    TInt task(0); //ETaskNone

    CBufBase* taskParam(NULL);

    taskQueue->AddTaskL( task,

                          this,        // task queue observer

                          0,           // Integer paramter, not used

                          taskParam,   // task queue assumes ownership of taskParam

                          NULL,        // Ptr data 

                          NULL,

                          NULL );   

    taskQueue->RemoveTask();

    delete taskQueue;

	FTRACE(FPrint(_L("CCommonTestClass::RemoveTask2CMPXTaskQueueL testing CMPXTaskQueue::RemoveTask end err=%d"), err));

    iLog->Log(_L("CCommonTestClass::RemoveTask2CMPXTaskQueueL testing CMPXTaskQueue::RemoveTask end err=%d"), err);

	return err;

    }

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

// CCommonTestClass::TaskCMPXTaskQueueL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::TaskCMPXTaskQueueL()

    {

	FTRACE(FPrint(_L("CCommonTestClass::TaskCMPXTaskQueueL testing CMPXTaskQueue::Task begin")));

    iLog->Log(_L("CCommonTestClass::TaskCMPXTaskQueueL testing CMPXTaskQueue::Task begin"));

    TInt err = KErrNone;

    CMPXTaskQueue* taskQueue = CMPXTaskQueue::NewL();

    TInt task(0); //ETaskNone

    CBufBase* taskParam(NULL);

    taskQueue->AddTaskL( task,

                          this,        // task queue observer

                          0,           // Integer paramter, not used

                          taskParam,   // task queue assumes ownership of taskParam

                          NULL,        // Ptr data 

                          NULL,

                          NULL );   

    taskQueue->Task();

    delete taskQueue;

	FTRACE(FPrint(_L("CCommonTestClass::TaskCMPXTaskQueueL testing CMPXTaskQueue::Task end err=%d"), err));

    iLog->Log(_L("CCommonTestClass::TaskCMPXTaskQueueL testing CMPXTaskQueue::Task end err=%d"), err);

	return err;

    }

void CCommonTestClass::ExecuteTask(TInt /*aTask*/, TInt /*aParamData*/, 

                             TAny* /*aPtrData*/,

                             const CBufBase& /*aBuf*/,

                             TAny* /*aCallback*/,

                             CBase* /*aCObject1*/,

                             CBase* /*aCObject2*/)

    {

	FTRACE(FPrint(_L("CCommonTestClass::ExecuteTask is called")));

    iLog->Log(_L("CCommonTestClass::ExecuteTask is called"));

    }

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

// CCommonTestClass::CreateCMPXTaskQueue()

// Returns: Symbian OS errors.

// add CreateCMPXTaskQueue to testmpxactivetaskqueue.cpp

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

TInt CCommonTestClass::CreateCMPXTaskQueue()

    {

      FTRACE(FPrint(_L("CCommonTestClass::CreateCMPXTaskQueue testing CMPXTaskQueue::NewL() begin")));

    iLog->Log(_L("CCommonTestClass::CreateCMPXTaskQueue testing CMPXTaskQueue::NewL() begin"));

    TInt err = KErrNone;

    CMPXTaskQueue* taskQueue = NULL;

    TRAP(err, taskQueue = CMPXTaskQueue::NewL());

    if ( taskQueue == NULL)

        {

        err = KErrNotFound;

        }

    delete taskQueue;

      FTRACE(FPrint(_L("CCommonTestClass::CreateCMPXTaskQueue testing CMPXTaskQueue::NewL() end err=%d"), err));

    iLog->Log(_L("CCommonTestClass::CreateCMPXTaskQueue testing CMPXTaskQueue::NewL() end err=%d"), err);

      return err;

    }

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

// CCommonTestClass::DeleteCMPXTaskQueue()

// Returns: Symbian OS errors.

// add CreateCMPXTaskQueue to testmpxactivetaskqueue.cpp

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

TInt CCommonTestClass::DeleteCMPXTaskQueue()

    {

      FTRACE(FPrint(_L("CCommonTestClass::DeleteCMPXTaskQueue testing CMPXTaskQueue::~ begin")));

    iLog->Log(_L("CCommonTestClass::DeleteCMPXTaskQueue testing CMPXTaskQueue::~ begin"));

    TInt err = KErrNone;

    CMPXTaskQueue* taskQueue = NULL;

    TRAP(err , taskQueue = CMPXTaskQueue::NewL());

    delete taskQueue;

    taskQueue=NULL;

      FTRACE(FPrint(_L("CCommonTestClass::DeleteCMPXTaskQueue testing CMPXTaskQueue::~ end err=%d"), err));

    iLog->Log(_L("CCommonTestClass::DeleteCMPXTaskQueue testing CMPXTaskQueue::~ end err=%d"), err);

      return err;

    }

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

// CCommonTestClass::ScheduleNextTaskCMPXTaskQueue()

// Returns: Symbian OS errors.

// add ScheduleNextTaskCMPXTaskQueue to testmpxactivetaskqueue.cpp

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

TInt CCommonTestClass::ScheduleNextTaskCMPXTaskQueue()

    {

      FTRACE(FPrint(_L("CCommonTestClass::ScheduleNextTaskCMPXTaskQueue testing CMPXTaskQueue::ScheduleNextTask begin")));

    iLog->Log(_L("CCommonTestClass::ScheduleNextTaskCMPXTaskQueue testing CMPXTaskQueue::ScheduleNextTask begin"));

    TInt err = KErrNone; 

    CMPXActiveTaskQueue* taskQueue = NULL;

    TRAP(err , taskQueue = CMPXActiveTaskQueue::NewL());

    taskQueue->ScheduleNextTask();

    delete taskQueue;

      FTRACE(FPrint(_L("CCommonTestClass::ScheduleNextTaskCMPXTaskQueue testing CMPXTaskQueue::ScheduleNextTask end err=%d"), err));

    iLog->Log(_L("CCommonTestClass::ScheduleNextTaskCMPXTaskQueue testing CMPXTaskQueue::ScheduleNextTask end err=%d"), err);

      return err;

    }

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

// CCommonTestClass::ResetCMPXTaskQueue()

// Returns: Symbian OS errors.

// add ResetCMPXTaskQueue to testmpxactivetaskqueue.cpp

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

TInt CCommonTestClass::ResetCMPXTaskQueue()

    {

      FTRACE(FPrint(_L("CCommonTestClass::ResetCMPXTaskQueue testing CMPXTaskQueue::Reset begin")));

    iLog->Log(_L("CCommonTestClass::ResetCMPXTaskQueue testing CMPXTaskQueue::Reset begin"));

    TInt err = KErrNone;

    CMPXTaskQueue* taskQueue = NULL;

    TRAP(err , taskQueue = CMPXTaskQueue::NewL());

    TInt task(0); //ETaskNone

    CBufBase* taskParam(NULL);

    TRAP(err, taskQueue->AddTaskL( task,

                          NULL,   // callback when task completed

                          NULL,        // task queue observer

                          0,           // Integer paramter, not used

                          taskParam,   // task queue assumes ownership of taskParam

                          NULL,        // Ptr data 

                          NULL ));   

    taskQueue->Reset();

    delete taskQueue;

      FTRACE(FPrint(_L("CCommonTestClass::ResetCMPXTaskQueue testing CMPXTaskQueue::Reset end err=%d"), err));

    iLog->Log(_L("CCommonTestClass::ResetCMPXTaskQueue testing CMPXTaskQueue::Reset end err=%d"), err);

      return err;

    }

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

// CCommonTestClass::DeleteCMPXActiveTaskQueue()

// Returns: Symbian OS errors.

// add DeleteCMPXActiveTaskQueue to testmpxactivetaskqueue.cpp

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

TInt CCommonTestClass::DeleteCMPXActiveTaskQueue()

    {

      FTRACE(FPrint(_L("CCommonTestClass::DeleteCMPXActiveTaskQueue testing  CMPXTaskQueue::~CMPXActiveTaskQueue begin")));

    iLog->Log(_L("CCommonTestClass::DeleteCMPXActiveTaskQueue testing CMPXTaskQueue::~CMPXActiveTaskQueue begin"));

    TInt err = KErrNone;

    CMPXActiveTaskQueue* taskQueue = NULL;

    TRAP(err , taskQueue = CMPXActiveTaskQueue::NewL());

    delete taskQueue;

    taskQueue=NULL;

      FTRACE(FPrint(_L("CCommonTestClass::DeleteCMPXActiveTaskQueue testing CMPXTaskQueue::~CMPXActiveTaskQueue end err=%d"), err));

    iLog->Log(_L("CCommonTestClass::DeleteCMPXActiveTaskQueue testing CMPXTaskQueue::~CMPXActiveTaskQueue end err=%d"), err);

      return err;

    }