diff -r 000000000000 -r 2f259fa3e83a lafagnosticuifoundation/cone/tef/TCONE6STEP.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lafagnosticuifoundation/cone/tef/TCONE6STEP.CPP Tue Feb 02 01:00:49 2010 +0200 @@ -0,0 +1,1445 @@ +// Copyright (c) 2005-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: +// Tests interface between container control and component controls.\n +// +// + +/** + @file + @internalComponent - Internal Symbian test code +*/ + +#include +#include +#include +#include +#include +#include +#include +#include "TCone6Step.h" +#include + +/** Constructor fo CCtlBase class.\n */ + +CCtlBase::CCtlBase() + { + } + +/** + Second phase constructor for CCtlBase Class.\n + Creates a font for the default graphics device, based on the specified TFontSpec.\n + Initiazes the screen font for the control.\n +*/ +void CCtlBase::ConstructL() + { + TFontSpec spec(_L("Arial"),240); + iFont = iCoeEnv->CreateScreenFontL( spec ) ; + } +/** Destructor for CCtlBase class.\n */ + +CCtlBase::~CCtlBase() + { + iCoeEnv->ReleaseScreenFont(iFont); + } +/** + Writes the text "aText" on the control.\n + Sets the font,pen colour,brush style used for writing the text.\n + Draws the text uisng Draw Text function of Graphics context.\n +*/ +void CCtlBase::WriteName( CWindowGc& aGc, const TDesC& aText ) const + { + TRect rect = Rect() ; + rect.Shrink( 3, 3 ) ; + aGc.UseFont( iFont ) ; + TInt ascent = ( rect.iBr.iY - rect.iTl.iY-iFont->HeightInPixels() ) / 2 + iFont->AscentInPixels() ; + aGc.SetPenColor( KRgbBlack ) ; + aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ) ; + aGc.DrawText( aText, rect, ascent, CGraphicsContext::ECenter ) ; + } +/** + Draw function for the CCtlBase class.\n + +*/ +void CCtlBase::DoDraw( CWindowGc& aGc, TRect aRect ) const + { + aGc.DrawRect( aRect ) ; + aRect.Shrink( 1, 1 ) ; + aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ) ; + aGc.DrawRect( aRect ) ; + WriteName( aGc, *iName ) ; + } + +/** + Constructor for CTestMCoeFocusObserver class.\n +*/ +CTestMCoeFocusObserver::CTestMCoeFocusObserver(CCoeControl& aContainer) : iCtlContainer(aContainer) + { + } +/** + Destructor for CTestMCoeFocusObserver class.\n +*/ +CTestMCoeFocusObserver::~CTestMCoeFocusObserver() + { + } + +void CTestMCoeFocusObserver::HandleChangeInFocus() + { + } +/** + Handles destruction of any control. It is called by framework if any control is destroyed.\n + Accesses the component controls to make sure the components are not removed from + CCoeControlArray before notifying the observer.\n +*/ +void CTestMCoeFocusObserver::HandleDestructionOfFocusedItem() + { + TInt cnt = iCtlContainer.CountComponentControls(); + while(cnt--) + { + CCoeControl* child = iCtlContainer.ComponentControl(cnt); + child->SetFocus(ETrue); // use control to make sure its not deleted + } + } + +/** + Constructor for the CCtlContainer class.\n +*/ +CCtlContainer::CCtlContainer() + { + } +/** + Destructor for CCtlContainer class.\n + Deletes the iName member variable.\n +*/ +CCtlContainer::~CCtlContainer() + { + // kids should be destroyed automatically + delete iName ; + } +/** + Second phase constructor for CCtlContainer class.\n + Invokes the base class "CCtlBase" second phase constructor.\n + Adds three objects each of CCtlContainee class as component controls.\n + The first two are added using a component Id while the same is not provided for the third control.\n + The container control window is activated.\n +*/ +void CCtlContainer::ConstructL( const TDesC& aName ) + { + CCtlBase::ConstructL() ; + // construct the kids, add them to the array. + iName = aName.AllocL() ; + CreateWindowL() ; + InitComponentArrayL(); + + CCtlContainee* child = NULL ; + child = new (ELeave) CCtlContainee ; + Components().AppendLC( child, KChildOneID ) ; + child->ConstructL( _L("child1") ) ; + CleanupStack::Pop( child ) ; + + child = new (ELeave) CCtlContainee ; + Components().AppendLC( child, KChildTwoID ) ; + child->ConstructL( _L("child2") ) ; + CleanupStack::Pop( child ) ; + + CCtlContainee* temp = new (ELeave) CCtlContainee ; + Components().AppendLC( temp ) ; + temp ->ConstructL( _L("orphan") ) ; + CleanupStack::Pop( temp ) ; + iOrphan = temp ; + + ActivateL() ; + } +/** + Sets the size of the component objects based on the present size of the container window.\n + Calculates the present size of the container control and also the number of component objects.\n + Sets the component object dimensions accordingly.\n +*/ +void CCtlContainer::SizeChanged() + { + // set the size of the children + TRect rect = Rect() ; + TSize size = rect.Size() ; + TPoint tl = rect.iTl ; + TInt childCount = CountComponentControls() ; + if ( childCount > 0 ) + { + size.iWidth = size.iWidth/childCount ; + size.iHeight = size.iHeight/childCount ; + CCoeControl* child ; + for ( TInt ii = 0; ii < childCount ; ++ii ) + { + child = ComponentControl( ii ) ; + child->SetRect( TRect( tl, size ) ) ; + tl.iX += size.iWidth ; + tl.iY += size.iHeight ; + } + } + } +/** + Draw function to draw the container control.\n + Gets a handle to the Windows Graphic context.\n + Calculates the present dimensions of the control and invokes the DoDraw function.\n +*/ +void CCtlContainer::Draw( const TRect& /*aRect*/ ) const + { + // get a graphics contect - outline the control + CWindowGc& gc=SystemGc(); + TRect rect=Rect(); + gc.SetBrushColor( KRgbBlue ) ; + DoDraw( gc, rect ) ; + } + +/** + @SYMTestCaseID UIF-TCone6Step-TestRemoveControlById + + @SYMPREQ + + @SYMTestCaseDesc Removes a component with Id KChildTwoID using API RemoveComponentById.\n + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions : Removes a component control using Component Id.\n + Removes a component with Id KChildTwoID using API RemoveComponentById.\n + The API removes a component control from a component array. + It also sets the component's parent to NULL.\n + The component control is later deleted.\n + + @SYMTestExpectedResults : Boolean, True if Component control is deleted.\n + + @SYMTestType : CIT +*/ +TBool CCtlContainer::TestRemoveControlById() + { + TBool seemsOK ; + TInt count = CountComponentControls() ; + CCoeControl* runt = NULL ; + runt = Components().RemoveById( KChildTwoID ) ; + + seemsOK = ( ( runt != NULL ) && ( CountComponentControls() == (count - 1) )) ; + + // So far, so good. This is a good time to test RemoveComponent() for non-existant + if ( seemsOK ) + { + TInt err = Components().Remove( runt ) ; // should return KErrNotFound + seemsOK = ( err == KErrNotFound ) ; + } + + delete runt ; + return seemsOK ; + } +/** + @SYMTestCaseID UIF-TCone6Step-TestCleanupL + + @SYMPREQ + + @SYMTestCaseDesc The functions tests clean up after forced memory fail.\n + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions : The functions tests clean up after forced memory fail.\n + The present number of component controls is obtained using CountComponentControls.\n + The next memory allocation is caused to fail using macro "__UHEAP_FAILNEXT".\n + A new component is added using AddComponentByIdLC API.\n + The number of component controls should remain the same after memory allocation failure also .\n + + @SYMTestExpectedResults : Boolean, True if Clean up is successful after memory allocation failure.\n + + @SYMTestType : CIT +*/ +TBool CCtlContainer::TestCleanupL() + { + + TBool seemsOK = EFalse ; + + // Initial count of controls + TInt count = CountComponentControls() ; + + // Create a new control to add to the array + CCtlContainee* child = NULL ; + child = new (ELeave) CCtlContainee ; + + // Set memory allocation to fail + __UHEAP_MARK ; + __UHEAP_SETFAIL((RHeap::EDeterministic),1); + + // Expect addition of the control to the array to fail + TRAPD(err, + { + Components().AppendLC( child ); + CleanupStack::Pop(child); + } ); + + // Re-align the heap + __UHEAP_RESET ; + __UHEAP_MARKEND ; + + // The no of controls should be the same as at the start + // as appending should have failed with KErrNoMemory + seemsOK = ( (count == CountComponentControls()) && + (err == KErrNoMemory)) ; + + return seemsOK ; + } +/** + @SYMTestCaseID UIF-TCone6Step-TestGetControlL + + @SYMPREQ + + @SYMTestCaseDesc Tests the ability to obtain handle to the component control using Component Id.\n + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions : Third component control is added using AddComponentByIdLC API with KChildThreeID as component ID.\n + Later the ID is passed to ComponentById API which returns the pointer to the component control.\n + The name of the control obtained is verified against the one set.\n + + @SYMTestExpectedResults : Boolean, True if names match.\n + + @SYMTestType : CIT +*/ +TBool CCtlContainer::TestGetControlL() + { + _LIT( KNameDes, "childx") ; + // construct a control, add it. Get one back. is it the same one? + CCtlContainee* child = NULL ; + child = new (ELeave) CCtlContainee ; + Components().AppendLC( child, KChildThreeID ) ; + child->ConstructL( KNameDes ) ; + CleanupStack::Pop( child ) ; + + CCoeControl* anotherChild = NULL ; + anotherChild = Components().ControlById(KChildThreeID); + TInt match = 1 ; + if ( anotherChild ) + { + match = KNameDes().Compare( static_cast(anotherChild)->WhoAmI() ) ; + } + return ( match == 0 ) ; + } +/** + @SYMTestCaseID UIF-TCone6Step-TestGetControlConstL + + @SYMPREQ + + @SYMTestCaseDesc Gets a constant handle to the component control.\n + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions : Gets a constant handle to the component control.\n + Handle to component with Id KChildThreeID is obtained using ComponentById API.\n + The name of the control obtained is verified against the KNameDes descriptor.\n + + @SYMTestExpectedResults : Boolean, True if names match.\n + + @SYMTestType : CIT +*/ +TBool CCtlContainer::TestGetControlConstL() const + { // dependant on TestGetControlL() + _LIT( KNameDes, "childx") ; + const CCtlContainee* anotherChild = NULL ; + anotherChild = Components().ControlById(KChildThreeID); + + TInt match = 1 ; + if ( anotherChild ) + { + match = KNameDes().Compare((anotherChild)->WhoAmI() ) ; + } + return ( match == 0 ) ; + } +/** + @SYMTestCaseID UIF-TCone6Step-TestGetUnknownControlConstL + + @SYMPREQ + + @SYMTestCaseDesc Gets a constant handle to the non existant component control .\n + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions : Component control with ID KChildTwoID does not exist.\n + Handle to component with Id KChildTwoID is obtained using ComponentById API.\n + + @SYMTestExpectedResults : Boolean, True if obtained component control pointer is NULL.\n + + @SYMTestType : CIT +*/ +TBool CCtlContainer::TestGetUnknownControlConstL() const + { // dependant on TestGetControlL and TestRemoveControl which removes child2 + const CCoeControl* anotherChild = NULL ; + anotherChild = Components().ControlById( KChildTwoID ) ; + return ( anotherChild == NULL ) ; + } + +/** + @SYMTestCaseID UIF-TCone6Step-TestAddDuplicateControlL + + @SYMPREQ + + @SYMTestCaseDesc Tests adding a component control using an already used Id.\n + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions : Tests adding a component control using an already used Id.\n + A component is created and added with Id 'KChildThreeID' which is already used.\n + + @SYMTestExpectedResults : Boolean, True if addition of duplicate control fails.\n + + @SYMTestType : CIT +*/ +TBool CCtlContainer::TestAddDuplicateControlL() + { + _LIT( KNameDes, "childx") ; + // construct a control, add it using an already used ID. Dependant on TestGetControlL() + CCtlContainee* child = NULL ; + child = new (ELeave) CCtlContainee ; + TInt err ; + __UHEAP_MARK ; + TRAP( err, Components().AppendLC( child, KChildThreeID ) ) ; + __UHEAP_MARKEND ; + if ( err == KErrNone ) + { + child->ConstructL( KNameDes ) ; + CleanupStack::Pop( child ) ; + return EFalse ; // test failed + } + else + { + return ETrue ; + } + } +/** + @SYMTestCaseID UIF-TCone6Step-TestRemoveNonExistantById + + @SYMPREQ + + @SYMTestCaseDesc Tests removal of a control using a non existant component ID.\n + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions : Tests removal of a control using a non existant component ID.\n + The number of component controls is obtained uisng CountComponentControls.\n + The a control with Id '99' which is non existant is removed using API 'RemoveComponentById'.\n + + @SYMTestExpectedResults : Boolean, True if the number of controls remains the same and object pointer returned by + RemoveComponentById is NULL.\n + + @SYMTestType : CIT +*/ +TBool CCtlContainer::TestRemoveNonExistantById() + { + TBool seemsOK ; + TInt count = CountComponentControls() ; + CCoeControl* runt = NULL ; + + runt = Components().RemoveById( 99 ) ; + + TInt postCount = CountComponentControls() ; + seemsOK = ( ( runt == NULL ) && ( CountComponentControls() == count ) ) ; + return seemsOK ; + } +/** + @SYMTestCaseID UIF-TCone6Step-TestRemoveControlL + + @SYMPREQ + + @SYMTestCaseDesc Tests removal of a control without using a control ID.\n + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions : Tests removal of a control without using a control ID.\n + A new component control is created and is added to the container control using API 'AddComponentByIdLC'.\n + The number of component controls is obtained using 'CountComponentControls' API.\n + The newly added component control is removed using API 'RemoveComponent' passing the pointer as argument.\n + + @SYMTestExpectedResults : Boolean, True if RemoveComponent returns KErrNone and + number of component control is decreased by One.\n + + @SYMTestType : CIT +*/ +TBool CCtlContainer::TestRemoveControlL() // See also TestRemoveControById() + { + _LIT( KNameDes, "child4") ; + // construct a control, add it. Remove it. Is it removed? + CCtlContainee* child = NULL ; + child = new (ELeave) CCtlContainee ; + Components().AppendLC( child, KChildFourID ) ; + child->ConstructL( KNameDes ) ; + CleanupStack::Pop( child ) ; + + TInt count = CountComponentControls() ; + TInt err = Components().Remove( child ) ; // should return KErrNone + TInt seemsOK = ( ( err == KErrNone ) && ( CountComponentControls() == (count - 1) )) ; + + delete child ; + return seemsOK ; + } +/** + @SYMTestCaseID UIF-TCone6Step-TestGetUnsetUniqueHandle + + @SYMPREQ + + @SYMTestCaseDesc Tests getting a unique handle to a component control without prior setting.\n + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions : Gets the handle to a component control with ID (KChildOneID).\n + A unique handle(KUniqueId) is not set to the above control using 'SetUniqueHandle' API prior to calling the get function.\n + + @SYMTestExpectedResults : Boolean, True if the obtained handle is equal to Zero.\n + + @SYMTestType : CIT +*/ +TBool CCtlContainer::TestGetUnsetUniqueHandle() + { + // will panic in debug + TInt handle = Components().ControlById( KChildOneID )->UniqueHandle() ; + // ignore error + return ( handle == KErrNotFound ) ; + + } +//! Unique Id used to identify a component control.\n +const TInt KUniqueId = 0x5AD ; +/** + @SYMTestCaseID UIF-TCone6Step-TestSetUniqueHandle + + @SYMPREQ + + @SYMTestCaseDesc Tests setting a unique handle to a component control.\n + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions : Sets a Unique Handle( KUniqueId )to a component Control with ID( KChildOneID).\n + + @SYMTestExpectedResults : Boolean,True if SetUniqueHandle returns KErrNone.\n + + @SYMTestType : CIT +*/ +TBool CCtlContainer::TestSetUniqueHandle() + { + TInt err = Components().ControlById( KChildOneID )->SetUniqueHandle( KUniqueId ) ; + return ( err == KErrNone ) ; + } +/** + @SYMTestCaseID UIF-TCone6Step-TestGetUniqueHandle + + @SYMPREQ + + @SYMTestCaseDesc Tests getting a unique handle to a component control.\n + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions : Gets the handle to a component control with ID (KChildOneID).\n + A unique handle(KUniqueId) is set to the above control using 'SetUniqueHandle' API prior to calling the get function.\n + + @SYMTestExpectedResults : Boolean, True if the obtained handle is equal to KUniqueId.\n + + @SYMTestType : CIT +*/ +TBool CCtlContainer::TestGetUniqueHandle() + { + TInt handle = Components().ControlById( KChildOneID )->UniqueHandle() ; + return ( handle == KUniqueId ) ; + } +/** + @SYMTestCaseID UIF-TCone6Step-TestSetUniqueHandleOOM + + @SYMPREQ + + @SYMTestCaseDesc Tests Setting a unique handle to a component control with forced memory allocation failure.\n + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions : A new component control is created .\n + The next memory allocation is caused to fail using macro '__UHEAP_FAILNEXT( 1 )'.\n + A unique handle(KUniqueId) is set to the above control using 'SetUniqueHandle' API.\n + + @SYMTestExpectedResults : Boolean, True if SetUniqueHandle returns KErrNoMemory.\n + + @SYMTestType : CIT +*/ +TBool CCtlContainer::TestSetUniqueHandleOOM() + { + CCtlContainee* child = NULL ; + child = new (ELeave) CCtlContainee ; + child->SetContainerWindowL(*this); + child->ActivateL(); // By activating the control its reserved memory is purged, so that the SetUniqueHandle() call can fail below. + __UHEAP_MARK ; + __UHEAP_FAILNEXT( 1 ) ; + TInt err = child->SetUniqueHandle( KUniqueId ) ; + __UHEAP_RESET ; + __UHEAP_MARKEND ; + delete child ; + return ( err == KErrNoMemory ) ; + } + +NONSHARABLE_CLASS(RDebugHeap) : public RHeap + { +public: + static bool OOMTrigered() + { + RDebugHeap& heap = STATIC_CAST(RDebugHeap&,User::Heap()); + return (!(heap.iFailAllocCount%heap.iFailRate) && (RAllocator::ENone == heap.iFailType)); + } + static bool OOMComplete() + { + RDebugHeap& heap = STATIC_CAST(RDebugHeap&,User::Heap()); + return ((RAllocator::EFailNext == heap.iFailType) && (heap.iFailAllocCount%heap.iFailRate)); + } + }; + +TBool CCtlContainer::TestInsertAfter() + { + _LIT(KNameDes, "child3"); + CCtlContainee* child = NULL; + + TInt err; + TInt oomCount = 1; + +#ifdef __WINS__ + while(oomCount < 100) + { + __UHEAP_FAILNEXT(oomCount); + err = KErrNone; +#endif + TRAP(err, + { + child = new (ELeave) CCtlContainee; + Components().InsertAfterLC(KChildOneID, child, KChildFiveID); + child->ConstructL(KNameDes); + CleanupStack::Pop(child); + }); +#ifdef __WINS__ + if (RDebugHeap::OOMTrigered()) + { + __UHEAP_RESET; + if(err == KErrNone) + { + if(Components().At(1).iId != KChildFiveID) + { + return EFalse; + } + Components().Remove( child ); + delete child; + } + if(Components().At(1).iId == KChildFiveID) + { + return EFalse; + } + if(err != KErrNone && err != KErrNoMemory) + { + return EFalse; + } + + // If we get to here, it was a properly-handled OOM situation + oomCount++; + } + else if(RDebugHeap::OOMComplete()) + { + __UHEAP_RESET; + break; + } + else + { + __UHEAP_RESET; + return EFalse; + } + } +#endif + if (err == KErrNone && oomCount != 100) + { + if (Components().At(1).iId == KChildFiveID) + { + return ETrue; + } + else + { + return EFalse; + } + } + else + { + return EFalse; + } + } + +//Tests the Insertion of the control after the last control using InsertAfterLC +TBool CCtlContainer::TestInsertLast() + { + _LIT(KNameDes, "child6"); + CCtlContainee* child = NULL; + child = new (ELeave) CCtlContainee; + + TRAPD(err, + { + Components().InsertAfterLC(KChildOneID, child, KChildSixID); + child->ConstructL(KNameDes); + CleanupStack::Pop(child); + }); + if (err == KErrNone) + { + if (Components().At(3).iId == KChildSixID) + { + return ETrue; + } + else + { + return EFalse; + } + } + else + { + return EFalse; + } + } + +/** + @SYMTestCaseID UIF-TCone6Step-TestFailingInsertAfter + + @SYMPREQ + + @SYMTestCaseDesc Tests that InsertAfterLC() works correctly when invalid reference component id is given.\n + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions : Creates a child and tries to add it using invalid reference component id.\n + + @SYMTestExpectedResults : Boolean, True.\n + + @SYMTestType : CIT +*/ +TBool CCtlContainer::TestFailingInsertAfter() + { + __UHEAP_MARK; + CCtlContainee* child = new(ELeave) CCtlContainee; + TRAPD(err, Components().InsertAfterLC(KErrNotFound, child)); + __UHEAP_MARKEND; + return (err == KErrNotFound); + } + +TBool CCtlContainer::TestId() + { + if (Components().Id(*Components().At(0).iControl) == KChildOneID) + { + return ETrue; + } + else + { + return EFalse; + } + } + +TBool CCtlContainer::TestCursor() + { + CCoeControlArray::TCursor cursor = Components().Begin(); + CCoeControl* child = cursor.Control(); + // Check that begin points to the first control + if (Components().Id(*child) != KChildOneID) + { + return EFalse; + } + // Check that next points to the second control + // The test TestInsertAfter will have put the corresponding + // control in the second position + if (cursor.Next()) + { + CCoeControl* child = cursor.Control(); + if (Components().Id(*child) != KChildFiveID) + { + return EFalse; + } + } + else + { + return EFalse; + } + // Go back by one and check again + if (cursor.Prev()) + { + CCoeControl* child = cursor.Control(); + if (Components().Id(*child) != KChildOneID) + { + return EFalse; + } + } + else + { + return EFalse; + } + + // Check == and != + CCoeControlArray::TCursor cursor2 = Components().Begin(); + if (!(cursor == cursor2) || (cursor != cursor2)) + { + return EFalse; + } + cursor.Next(); + if ((cursor == cursor2) || !(cursor != cursor2)) + { + return EFalse; + } + + return ETrue; + } + +TBool CCtlContainer::TestFind() + { + CCoeControlArray::TCursor cursor = Components().Find(KChildOneID); + if (!cursor.IsValid()) + { + return EFalse; + } + CCoeControl* control = Components().At(0).iControl; + CCoeControlArray::TCursor cursor2 = Components().Find(control); + if (!cursor2.IsValid()) + { + return EFalse; + } + // Check that an inexistent id returns a "null" cursor + CCoeControlArray::TCursor cursor3 = Components().Find(76765); + if (cursor3.IsValid()) + { + return EFalse; + } + // Check that an inexistent control returns a "null" cursor + CCoeControl* dummyControl = new CCoeControl(); + CCoeControlArray::TCursor cursor4 = Components().Find(dummyControl); + delete dummyControl; + if (cursor4.IsValid()) + { + return EFalse; + } + + return ETrue; + } + +TBool CCtlContainer::TestSort() + { + //Removing the orphan control from array and deleting the control + User::LeaveIfError(Components().Remove(iOrphan)); + delete iOrphan; + iOrphan = 0; + CCtlContainee* child = NULL ; + child = new (ELeave) CCtlContainee ; + Components().InsertAfterLC(KChildOneID, child, KChildTwoID); + _LIT(KNameDes2, "child2"); + child->ConstructL(KNameDes2 ) ; + CleanupStack::Pop( child ) ; + + //Creates an object of 'TLinearOrder'. + TLinearOrder order(CCtlContainer::CompareControls); + + //Sorts the controls stored in the object. + //Before sorting the order of control in the array is 0, 1, 2. + Components().Sort(order); + + TBool sorted=ETrue; + + //Checking whether the controls are sorted in descending order or not + for(TInt i=0; i < Components().Count(); i++) + { + TInt k=Components().At(i).iId; + if (Components().At(i).iId != Components().Count() - i -1) + { + sorted=EFalse; + break; + } + } + return sorted; + } +TInt CCtlContainer::CompareControls(const TCoeControlWithId& aFirst, const TCoeControlWithId& aSecond) + { + //Algorithm to sort the controls in descending order based on the control id + //It will return 1,0 or -1. + return aSecond.iId - aFirst.iId; + } +TBool CCtlContainer::TestRemove() + { + CCoeControlArray::TCursor cursor = Components().Find(KChildFiveID); + if (!cursor.IsValid()) + { + return EFalse; + } + CCoeControl* control = Components().Remove(cursor); + if (!control) + { + return EFalse; + } + delete control; + + return ETrue; + } + +TBool CCtlContainer::TestReplace() + { + CCoeControlArray::TCursor cursor = Components().Find(KChildOneID); + if (!cursor.IsValid()) + { + return EFalse; + } + CCoeControl* ctrl = cursor.Control(); + CCtlContainee* child = new (ELeave) CCtlContainee; + TInt err = Components().Replace(ctrl, child); + if (err != KErrNone) + { + delete child; + return EFalse; + } + delete ctrl; + + // Check replacement of inexistent control + err = Components().Replace(ctrl, child); + if (err != KErrNotFound) + { + return EFalse; + } + + return ETrue; + } + +TBool CCtlContainer::TestSetArrayLocked() + { + Components().SetArrayLocked(); + if (!Components().IsArrayLocked()) + { + return EFalse; + } + CCtlContainee* child = NULL ; + child = new (ELeave) CCtlContainee ; + TRAPD(err, Components().AppendLC(child, KChildOneID)); + if (err != KErrLocked) + { + return EFalse; + } + return ETrue; + } + +/** + @SYMTestCaseID UIF-TCone6Step-TestOwnedExternally + + @SYMPREQ + + @SYMTestCaseDesc Tests that CCoeControlArray is behaving correctly when adding controls when they are owned externally.\n + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions : Creates a child removes and deletes it.\n + Creates a child and makes the cleanupstack item remove the child, and deletes the child.\n + Tries to add a CCtlUnparentableContainee and deletes it.\n + Creates a child and adds it using InsertAfterLC().\n + Tries to add a child but using an invalid component id for InsertAfterLC().\n + + @SYMTestExpectedResults : Boolean, True.\n + + @SYMTestType : CIT +*/ +TBool CCtlContainer::TestOwnedExternally() + { + Components().ResetAndDestroy(); + Components().SetControlsOwnedExternally(ETrue); + + // Test InsertLC() + + //normal usage + CCtlContainee* child = new(ELeave) CCtlContainee; + CleanupStack::PushL(child); + Components().AppendLC(child); + CleanupStack::Pop(child); + Components().Remove(child); + CleanupStack::PopAndDestroy(child); + + //emulate leave + child = new(ELeave) CCtlContainee; + CleanupStack::PushL(child); + Components().AppendLC(child); + CleanupStack::PopAndDestroy(child); //"leave" + CleanupStack::PopAndDestroy(child); + if(Components().Find(child).IsValid()) return EFalse; + + //SetParent() is called before the cleanup stack is created + //make sure there's no double deletion when the SetParent() call fails + CCtlUnparentableContainee* childOfNoone = new(ELeave) CCtlUnparentableContainee; + CleanupStack::PushL(childOfNoone); + TRAP_IGNORE(Components().AppendLC(childOfNoone)); + CleanupStack::PopAndDestroy(childOfNoone); + if(Components().Find(childOfNoone).IsValid()) return EFalse; + + // Test InsertAfterLC() + + //add a reference child + CCtlContainee* firstChild = new(ELeave) CCtlContainee; + CleanupStack::PushL(firstChild); + Components().AppendLC(firstChild, KChildOneID); + CleanupStack::Pop(firstChild); + + //insert successfully, remove by emulating leave + child = new(ELeave) CCtlContainee; + CleanupStack::PushL(child); + Components().InsertAfterLC(KChildOneID, child); + CleanupStack::PopAndDestroy(child); //"leave" + CleanupStack::PopAndDestroy(child); + if(Components().Find(child).IsValid()) return EFalse; + + //insert with invalid reference component id + child = new(ELeave) CCtlContainee; + CleanupStack::PushL(child); + TRAP_IGNORE(Components().InsertAfterLC(KErrNotFound, child)); + CleanupStack::PopAndDestroy(child); + if(Components().Find(child).IsValid()) return EFalse; + + //cleanup reference child + Components().Remove(firstChild); + CleanupStack::PopAndDestroy(firstChild); + + return (CountComponentControls() == 0); + } + +/** + @SYMTestCaseID UIF-TCone6Step-TestHandleDestructionOfFocusedItemL + + @SYMDEF DEF087937 MMS: MMS Editor - Messaging crash using jog dial to scroll through message wh... + + @SYMTestCaseDesc Tests the CCoeControl's destructor notifies the observer before + CCoeControl's CCoeControlArray components are deleted and the array is shrinked.\n + The observer should access CCoeControl::CountComponentsControl() and ComponentControl().\n + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions : The parent control is created and two child controls are added to it.\n + The parent control is registered with observer to get notification.\n + Delete both parent control and observer.\n + + @SYMTestExpectedResults : The CCoeControl's destructor notifies the observer before deleting + and shrinking the CCoeCotrolArray.\n + The observer accesses CoeControl::CountComponentsControl() and ComponentControl(). + + @SYMTestType : CIT +*/ +void CCtlContainer::TestHandleDestructionOfFocusedItemL() + { + CParentControl* parent = new (ELeave) CParentControl; + CleanupStack::PushL(parent); + parent->SetContainerWindowL(*this); + parent->InitComponentArrayL(); + + CCoeControl* child1 = new (ELeave) CCoeControl; + parent->Components().AppendLC(child1) ; + CleanupStack::Pop( child1 ); + + CCoeControl* child2 = new (ELeave) CCoeControl; + parent->Components().AppendLC(child2) ; + CleanupStack::Pop( child2 ); + + CTestMCoeFocusObserver* obs = new (ELeave) CTestMCoeFocusObserver(*parent) ; + CleanupStack::PushL(obs); + CCoeEnv::Static()->AddFocusObserverL(*obs); + CleanupStack::Pop(obs); + + // set both focused to make the test independent of deletion order + child1->SetFocus(ETrue); + child2->SetFocus(ETrue); + + // parent will delete its children + // obs will be notified via HandleDestructionOfFocusedItem + // obs will refer to deleted child1 + CleanupStack::PopAndDestroy(parent); + CCoeEnv::Static()->RemoveFocusObserver(*obs); + delete obs; + } + +CCtlContainee::CCtlContainee() + { + } +/** + Destructor for CCtlContainee classused for creating component controls.\n +*/ +CCtlContainee::~CCtlContainee() + { + delete iName ; + } +/** + Second phase constructor for CCtlContainee classused for creating component controls.\n + Invokes the base class second phase construtor.\n + Allocates a string which contains the ID of the component control.\n +*/ +void CCtlContainee::ConstructL( const TDesC& aName ) + { + CCtlBase::ConstructL() ; + iName = aName.AllocL() ; + } +/** + Function to draw the component control.\n + Obtains a handle to Windows Graphic Context.\n + Sets the Brush colour and invokes the DoDraw function.\n +*/ +void CCtlContainee::Draw(const TRect& /*aRect*/) const + { + CWindowGc& gc=SystemGc(); + TRect rect=Rect(); + gc.SetBrushColor( KRgbYellow ) ; + DoDraw( gc, rect ) ; + } +/** + Returns the string associated with the component control.\n + + @return String associated with the control.\n +*/ +const TDesC& CCtlContainee::WhoAmI() const + { + return *iName ; + } + + +/** + Constructor for CCone6TestAppUi class.\n + Sets the Test step Name.\n +*/ +CCone6TestAppUi::CCone6TestAppUi(CTmsTestStep* aStep) : +CTestCoeAppUi(aStep) +{} + +/** + Destructor for CCone6TestAppUi class.\n +*/ +CCone6TestAppUi::~CCone6TestAppUi() + { + delete iContainer ; + } + +/** + Second phase constructor for the CCone6TestAppUi class.\n + Invokes the base class CTestCoeAppUi ConstructL function.\n + Instantiates a container control object.\n + Sets the container control's extent using CCoeControl::SetExtent API.\n + Starts the asynchronous execution of tests using Auto test manager.\n +*/ +void CCone6TestAppUi::ConstructL() + { + INFO_PRINTF1(_L("App UI ConstructL")); + + CTestCoeAppUi::ConstructL(); + + ReinitializeContainerL(); + + AutoTestManager().StartAutoTest(); + } +/** + Makes sure the container is in its initial state.\n + Must be called by tests that make the container change state so that following + tests knows what to expect. +*/ +void CCone6TestAppUi::ReinitializeContainerL() + { + delete iContainer; + iContainer = NULL; + + iContainer = new (ELeave) CCtlContainer; + + iContainer->ConstructL( _L("Container") ) ; + iContainer->SetExtent( TPoint(20,20),TSize(600,200) ) ; + } + +/** + The function handles the key events received by CCone6Test AppUi.\n + Exits the application in case Ctrl + E is received.\n + + @return TKeyResponse, Indicating whether the key event has been handled or not.\n +*/ +TKeyResponse CCone6TestAppUi::HandleKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType) + { + TKeyResponse ret=EKeyWasNotConsumed; + if (aType==EEventKey && aKeyEvent.iCode==CTRL('e')) + { + CBaActiveScheduler::Exit(); + ret=EKeyWasConsumed; + } + return ret; + } + +/** + Auxilliary Function for all test cases.\n + This function is iteratively called by the RunL function of the Autotestmanager + asynchronously.\n + Calls the following function\n + 1. Draw the container.\n + 2. Make the control invisible and invoke Draw.\n + 3. Make the control visible and invoke Draw.\n + 4. Test the cleanup after forced memory fail.\n + 5. Test removing a component control using Id.\n + 6. Test Getting a control using a component Id.\n + 7. Test Getting a const pointer to a control .\n + 8. Addition of a duplicate control.\n + 9. Removal of a non existant control.\n + 10. Unsetting a unique handle.\n + 11. Setting a unique handle.\n + 12. Getting a unique handle.\n + + 25. Externally owned component controls.\n + 26. Failing InsertAfterLC().\n +*/ +void CCone6TestAppUi::RunTestStepL(TInt aStepNum) + { + + User::After(TTimeIntervalMicroSeconds32(1000000)); + + switch(aStepNum) + { + case 0 : + case 1 : + INFO_PRINTF1(_L("Test 6 case 1")); + iContainer->DrawNow() ; + break ; + case 2 : + INFO_PRINTF1(_L("Test 6: Case 2")); + iContainer->MakeVisible( EFalse ) ; + iContainer->DrawNow() ; + break ; + case 3 : + INFO_PRINTF1(_L("Test 6: Case 3")); + iContainer->MakeVisible( ETrue ) ; + iContainer->DrawNow() ; + break ; + case 4 : + INFO_PRINTF1(_L("Test 6: Case 4")); +#if defined( _DEBUG ) + TEST(iContainer->TestCleanupL()); +#endif + iContainer->DrawNow() ; + break ; + case 5 : + SetTestStepID(_L("UIF-TCone6Step-TestRemoveControlById")); + INFO_PRINTF1(_L("Test 6: Case 5")); + TEST( iContainer->TestRemoveControlById() ) ; + iContainer->DrawNow() ; + RecordTestResultL(); + break ; + case 6 : + SetTestStepID(_L("UIF-TCone6Step-TestGetControlL")); + INFO_PRINTF1(_L("Test 6: Case 6")); + TEST( iContainer->TestGetControlL() ) ; + RecordTestResultL(); + break ; + case 7 : + SetTestStepID(_L("UIF-TCone6Step-TestGetControlConstL")); + INFO_PRINTF1(_L("Test 6: Case 7")); + TEST( iContainer->TestGetControlConstL() ) ; + RecordTestResultL(); + break ; + case 8 : + SetTestStepID(_L("UIF-TCone6Step-TestGetUnknownControlConstL")); + INFO_PRINTF1(_L("Test 6: Case 8")); + TEST( iContainer->TestGetUnknownControlConstL() ) ; + RecordTestResultL(); + break ; + case 9 : + SetTestStepID(_L("UIF-TCone6Step-TestAddDuplicateControlL")); + INFO_PRINTF1(_L("Test 6: Case 9")); + // TEST( iContainer->TestAddDuplicateControlL() ) ; + RecordTestResultL(); + break ; + case 10 : + SetTestStepID(_L("UIF-TCone6Step-TestRemoveNonExistantById")); + INFO_PRINTF1(_L("Test 6: Case 10")); + TEST( iContainer->TestRemoveNonExistantById() ) ; + RecordTestResultL(); + break ; + case 11 : + SetTestStepID(_L("UIF-TCone6Step-TestRemoveControlL")); + INFO_PRINTF1(_L("Test 6: Case 11")); + TEST( iContainer->TestRemoveControlL() ) ; + RecordTestResultL(); + break ; + case 12 : + SetTestStepID(_L("UIF-TCone6Step-TestGetUnsetUniqueHandle")); + INFO_PRINTF1(_L("Test 6: Case 12")); + TEST( iContainer->TestGetUnsetUniqueHandle() ) ; + RecordTestResultL(); + break ; + case 13 : + SetTestStepID(_L("UIF-TCone6Step-TestSetUniqueHandle")); + INFO_PRINTF1(_L("Test 6: Case 13")); + TEST( iContainer->TestSetUniqueHandle() ) ; + RecordTestResultL(); + break ; + case 14 : + SetTestStepID(_L("UIF-TCone6Step-TestGetUniqueHandle")); + INFO_PRINTF1(_L("Test 6: Case 14")); + TEST( iContainer->TestGetUniqueHandle() ) ; + RecordTestResultL(); + break ; + case 15 : + INFO_PRINTF1(_L("Test 6: Case 15")); + TEST( iContainer->TestInsertAfter()); + break; + case 22 : + INFO_PRINTF1(_L("Test 6: Case 22")); + TEST( iContainer->TestInsertLast()); + break; + case 16 : + INFO_PRINTF1(_L("Test 6: Case 16")); + TEST( iContainer->TestId()); + break; + case 17 : + INFO_PRINTF1(_L("Test 6: Case 17")); + TEST( iContainer->TestCursor()); + break; + case 18 : + INFO_PRINTF1(_L("Test 6: Case 18")); + TEST( iContainer->TestFind()); + break; + case 19 : + INFO_PRINTF1(_L("Test 6: Case 19")); + TEST( iContainer->TestRemove()); + break; + case 20 : + INFO_PRINTF1(_L("Test 6: Case 20")); + TEST( iContainer->TestReplace()); + break; + case 21 : + INFO_PRINTF1(_L("Test 6: Case 21")); + TEST( iContainer->TestSort()); + break ; + case 23 : + SetTestStepID(_L("UIF-TCone6Step-TestHandleDestructionOfFocusedItemL")); + INFO_PRINTF1(_L("Test 6: Case 23")); + TRAPD(ret,iContainer->TestHandleDestructionOfFocusedItemL()); + TEST(ret == KErrNone); + RecordTestResultL(); + break; + case 24 : + INFO_PRINTF1(_L("Test 6: Case 24")); +#if defined( __WINS__ ) + TEST( iContainer->TestSetUniqueHandleOOM() ) ; +#else // No memory failure testing on hardware because UREL + TEST( ETrue) ; +#endif + break ; + case 25: + SetTestStepID(_L("UIF-TCone6Step-TestOwnedExternally")); + INFO_PRINTF1(_L("Test 6: Case 25")); + TEST( iContainer->TestOwnedExternally() ); + ReinitializeContainerL(); + RecordTestResultL(); + break; + case 26: + SetTestStepID(_L("UIF-TCone6Step-TestFailingInsertAfter")); + INFO_PRINTF1(_L("Test 6: Case 26")); + TEST( iContainer->TestFailingInsertAfter() ); + RecordTestResultL(); + CloseTMSGraphicsStep(); + break; + case 27 : + INFO_PRINTF1(_L("Test 6: Case 27")); + TEST( iContainer->TestSetArrayLocked()); + break; + default : + INFO_PRINTF1(_L("Test 6: Case default")); + AutoTestManager().FinishAllTestCases(CAutoTestManager::EPass); + break; + + } + } + + +/** + Completes the construction of the Control Environment(CCoeEnv object).\n + Instantiates the CCone6TestAppUi class which serves as a AppUi class.\n + Sets the CCone6TestAppUi object as the application's user interface object.\n + Invokes the second phase constructor of the application's UI.\n +*/ +void CTCone6Step::ConstructAppL(CCoeEnv* aCoe) + { // runs inside a TRAP harness + aCoe->ConstructL(); + CCone6TestAppUi* appUi= new (ELeave) CCone6TestAppUi(this); + aCoe->SetAppUi(appUi); + appUi->ConstructL(); + } +/** + Constructor for CTCone6Step class.\n + Sets the test step name.\n +*/ +CTCone6Step::CTCone6Step() + { + SetTestStepName(KTCone6Step); + } +/** + Destructor for CTCone6Step class.\n +*/ +CTCone6Step::~CTCone6Step() +{} + +/** + Entry function for CTCone6 Test Step.\n + Sets up the control environment.\n + Constructs and Launches the CTCone5 Test application.\n +*/ +TVerdict CTCone6Step::doTestStepL() // main function called by E32 + { + INFO_PRINTF1(_L("Test 6 Started")); + + PreallocateHALBuffer(); + + __UHEAP_MARK; + + CCoeEnv* coe=new(ELeave) CCoeEnv; + + TRAPD(err,ConstructAppL(coe)); + + if (!err) + { + coe->ExecuteD(); + } + else + { + SetTestStepResult(EFail); + delete coe; + } + + REComSession::FinalClose(); + + __UHEAP_MARKEND; + + INFO_PRINTF1(_L("Test Finished")); + return TestStepResult(); + } + +