diff -r 000000000000 -r 4e91876724a2 photosgallery/viewframework/commandhandlers/commoncommandhandlers/tsrc/ut_propertycommandhandlers/src/ut_propertycommandhandlers.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/photosgallery/viewframework/commandhandlers/commoncommandhandlers/tsrc/ut_propertycommandhandlers/src/ut_propertycommandhandlers.cpp	Thu Dec 17 08:45:44 2009 +0200
@@ -0,0 +1,375 @@
+/*
+* Copyright (c) 2004 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:  CommandHandlerDetails unit test cases
+*
+*/
+
+
+
+
+//  CLASS HEADER
+#include "UT_propertycommandhandlers.h"
+
+//#include <glxcommandhandlerproperties.h>
+#include <mglxmedialist.h>
+#include <mpxcollectionutility.h>
+#include <mpxcollectionpath.h>
+
+#include <glxcommandhandlers.hrh>
+//  EXTERNAL INCLUDES
+#include <EUnitMacros.h>
+
+//  INTERNAL INCLUDES
+
+template<typename T> 
+inline void CGlxMedia::SetTObjectValueL(const TMPXAttribute& aAttribute, T aValue) 
+	{
+    TAny* ptr = User::AllocL(sizeof(T));
+    memcpy(ptr, &aValue, sizeof(T));
+
+    TInt i = Index(aAttribute);
+    if (KErrNotFound != i)
+        {
+        // Replace the existing value
+        TValue& value = iValues[i];
+		// COMMENTED OUT SINCE NOT EXPORTED 
+		//Delete(value);
+        
+        value.iValue = ptr; // Takes ownership
+        value.iType = EMPXTypeTObject;
+        }
+    else
+        {
+        TInt err = iValues.Append(TValue(ptr, EMPXTypeTObject));
+        
+        // If appended value ok, try to append the attribute. 
+        if (KErrNone == err) 
+        	{
+	        err = iAttributes.Append(aAttribute);
+	        if (err != KErrNone)
+	        	{
+	        	// Failed, undo the append
+	        	iValues.Remove(iValues.Count() - 1);
+	        	}
+       		}
+       		
+        if (KErrNone != err) 
+        	{
+        	User::Free(ptr);
+        	User::Leave(err);
+        	}
+        }
+   	}
+   	
+//
+CGlxMedia::CGlxMedia(const TGlxMediaId& aId)
+		: iId(aId), iUsedByLists(2) // On average, two list as users assumed
+    {
+    }
+    
+CGlxMedia::~CGlxMedia()
+    {
+    iUsedByLists.Close();
+
+	Reset();
+    iValues.Close(); 
+    iAttributes.Close();
+    }    
+       	
+
+
+struct _CGlxTestMediaList: public CBase, public MGlxMediaList
+	{
+	~_CGlxTestMediaList() 
+	    {
+	    iItems.Close();
+        iMedia.ResetAndDestroy();
+        iSelectedItems.Close();
+	    }
+	    
+	virtual void Close() 
+	    {
+	    };
+	virtual TGlxMediaListId Id() const 
+	    {
+	    return KGlxIdNone;
+	    }
+
+    virtual TInt Count(TCountType aType = ECountAll) const
+	//virtual TInt Count() const 
+	    {
+	    return iItems.Count();
+	    }
+	
+	virtual TInt FocusIndex() const 
+	    {
+	    return iFocusIndex;
+	    }
+
+	virtual void SetFocusL(NGlxListDefs::TFocusSetType /*aType*/, TInt aValue) 
+	    {
+	    iFocusIndex = aValue;
+	    }
+	
+	virtual const TGlxMedia& Item(TInt aIndex) const 
+	    {
+	    return iItems[aIndex];
+	    }
+
+	virtual TInt Index(const TGlxMediaId& aId) const 
+	    {
+	    TInt count = iItems.Count();
+	    for (TInt i = 0; i < count; i++)
+	        {
+	        if (iItems[i].Id() == aId)
+	            {
+	            return i;
+	            }
+	        }
+	    return KErrNotFound;
+	    }
+	
+	virtual void AddMediaListObserverL(MGlxMediaListObserver* /*aObserver*/) 
+	    {
+	    }
+	
+	virtual void RemoveMediaListObserver(MGlxMediaListObserver* /*aObserver*/) 
+	    {
+	    }
+
+    virtual void AddContextL(const MGlxFetchContext* /*aContext*/, TInt /*aPriority*/) 
+        {
+        }
+
+	virtual void RemoveContext(const MGlxFetchContext* /*aContext*/) 
+	    {
+	    }
+	
+	virtual MMPXCollection& Collection() const 
+	    {
+	    return *(MMPXCollection*)NULL;
+	    }
+
+	virtual const TBool IsSelected(TInt aIndex) const 
+	    {
+	    TInt idx = iSelectedItems.Find(aIndex);
+	    return (idx != KErrNotFound);
+	    }
+
+	virtual void SetSelectedL(TInt aIndex, TBool aSelected) 
+	    {
+	    if (aSelected)
+	        {
+            iSelectedItems.InsertInOrder(aIndex);
+	        }
+	    else 
+	        {
+	        iSelectedItems.Remove(iSelectedItems.Find(aIndex));
+	        }
+	    }
+
+	virtual const TArray<TInt> Selection() const 
+	    {
+	    return iSelectedItems.Array();
+	    }
+
+	virtual void CommandL(CMPXCommand& /*aCommand*/) 
+	    {
+	    }
+
+	virtual void CancelCommand() 
+	    {
+	    }
+
+	virtual void SetFilterL(CMPXFilter* /*aFilter*/) 
+	    {
+	    }
+
+	virtual CMPXFilter* Filter() const 
+	    {
+	    return NULL;
+	    }
+
+    virtual TGlxIdSpaceId IdSpaceId() const 
+        {
+        return KGlxIdNone;
+        }
+    
+    void AppendL(TInt aId, TBool aCreateMedia) 
+        {
+        if (aCreateMedia) 
+            {
+            CGlxMedia* media = new (ELeave) CGlxMedia(TGlxMediaId(aId));
+            CleanupStack::PushL(media);
+            iMedia.AppendL(media);
+            TMPXAttribute uriAttr(KMPXMediaGeneralUri);
+            media->SetTextValueL (uriAttr,_L("testing"));
+            CleanupStack::Pop(media);
+            iItems.AppendL(TGlxMedia(TGlxMediaId(aId), media));
+            }
+        else 
+            {
+            iItems.AppendL(TGlxMedia(TGlxMediaId(aId)));
+            }
+        }
+        
+    CGlxMedia* MediaObj(TInt aIndex) const 
+        {
+        return const_cast<CGlxMedia*>(static_cast<const CGlxMedia*>(iItems[aIndex].Properties()));
+        }
+        
+    CMPXCollectionPath* PathLC() const
+    	{
+    	return NULL;
+    	}
+    
+    TInt SelectionCount() const
+    	{
+    	return iSelectedItems.Count();
+    	}
+    	
+    TInt SelectedItemIndex(TInt aSelectionIndex) const
+    	{
+    	return 0;
+    	}
+ 
+    virtual TBool IsPopulated() const
+        {
+        return ETrue;
+        }
+   
+    RArray<TGlxMedia> iItems;
+    RPointerArray<CGlxMedia> iMedia;
+    RArray<TInt> iSelectedItems;
+    TInt iFocusIndex;
+	};
+	
+// CONSTRUCTION
+
+MGlxMediaList& UT_propertycommandhandlers::MediaList() 
+	{
+	return *iMediaList;
+	}
+
+UT_propertycommandhandlers* UT_propertycommandhandlers::NewL()
+    {
+    UT_propertycommandhandlers* self = UT_propertycommandhandlers::NewLC();
+    CleanupStack::Pop();
+
+    return self;
+    }
+
+UT_propertycommandhandlers* UT_propertycommandhandlers::NewLC()
+    {
+    UT_propertycommandhandlers* self = new( ELeave ) UT_propertycommandhandlers();
+    CleanupStack::PushL( self );
+
+    self->ConstructL();
+
+    return self;
+    }
+  
+    
+// Destructor (virtual by CBase)
+UT_propertycommandhandlers::~UT_propertycommandhandlers()
+    {
+    }
+
+// Default constructor
+UT_propertycommandhandlers::UT_propertycommandhandlers()
+    {
+    }
+
+// Second phase construct
+void UT_propertycommandhandlers::ConstructL()
+    {
+    // The ConstructL from the base class CEUnitTestSuiteClass must be called.
+    // It generates the test case table.
+    CEUnitTestSuiteClass::ConstructL();
+    }
+
+//  METHODS
+
+
+
+void UT_propertycommandhandlers::SetupL(  )
+    {
+    //MMPXCollectionUtility* collectionUtility = MMPXCollectionUtility::NewL(NULL, KMcModeDefault);
+    //CMPXCollectionPath* path ;//= collectionUtility->Collection().PathL();
+		//iML = MGlxMediaList::InstanceL(*path,NULL);
+	iMediaList = new (ELeave) _CGlxTestMediaList;
+	iMediaList->AppendL(0, ETrue);
+	iMediaList->AppendL(1, ETrue);
+	iMediaList->AppendL(2, ETrue);
+	iMediaList->AppendL(3, ETrue);
+	iMediaList->AppendL(4, ETrue);
+	iMediaList->iFocusIndex = 0;
+	
+	iTagManagerCommand = CGlxCommandHandlerProperties::NewTagManagerCommandHandlerL(this);
+	iMetadataCommand = CGlxCommandHandlerProperties::NewMetadataViewCommandHandlerL(this);
+    }
+
+void UT_propertycommandhandlers::Teardown(  )
+    {
+    	
+	delete iTagManagerCommand;
+	delete iMetadataCommand;
+	
+	delete iMediaList;
+    }
+
+void UT_propertycommandhandlers::PropertyCommandHandlerNewL(  )
+    {
+    EUNIT_ASSERT( NULL != iTagManagerCommand );
+    EUNIT_ASSERT( NULL != iMetadataCommand );
+    }
+    
+void UT_propertycommandhandlers::PropertyCommandHandlerExecuteL(  )
+    {
+    //check that metadata command is consumend
+    EUNIT_ASSERT( iMetadataCommand->ExecuteL(EGlxCmdProperties) );
+    //check that tag manager command is not consumend
+    EUNIT_ASSERT( !iMetadataCommand->ExecuteL(EGlxCmdTagManager) );
+    
+    //check that tag manager command is consumend
+    EUNIT_ASSERT( iTagManagerCommand->ExecuteL(EGlxCmdTagManager) );
+    //check that metadata command is not consumend
+    EUNIT_ASSERT( !iTagManagerCommand->ExecuteL(EGlxCmdProperties) );
+    }
+
+//  TEST TABLE
+
+EUNIT_BEGIN_TEST_TABLE(
+    UT_propertycommandhandlers,
+    "Property command handler unit testing.",
+    "Property Command handler" )
+
+EUNIT_TEST(
+    "NewL ",
+    "CGlxCommandHandlerProperties",
+    "NewL",
+    "FUNCTIONALITY",
+    SetupL, PropertyCommandHandlerNewL, Teardown)
+    
+EUNIT_TEST(
+    "ExecuteL ",
+    "CGlxCommandHandlerProperties",
+    "ExecuteL",
+    "FUNCTIONALITY",
+    SetupL, PropertyCommandHandlerExecuteL, Teardown)
+
+
+EUNIT_END_TEST_TABLE
+
+//  END OF FILE