MCL/sf/mw/uiaccelerator: comparison uiacceltk/hitchcock/CommonInc/alfmoduletestmap.h

equal deleted inserted replaced

-:10534483575f
+:88b23e2e82e1
+/**
+* @note This class is provided only if module test hooks are set on.
+*/
+#include "alfmoduletestconf.h"
+#ifdef USE_MODULE_TEST_HOOKS_FOR_ALF
+#ifndef ALFMODULETESTMAP_H
+#define ALFMODULETESTMAP_H
+#include <e32def.h>
+#include "alfmoduletestitem.h"
+#include "alfmoduletesttype.h"
+/**
+* Class CAlfModuleTestMap
+*
+* Provides map functionality for the key-value-pairs.
+* In test cases, this should most likely be used so, that
+* first test case classes create items with certain keys, for example with handle values.
+* Then, define hooks are used in the code to update values that corresond the correct handles.
+* In the end, test case classes can check that items have correct values set and if the test
+* is passed.
+*
+* @note When this item is copied, also the contents of the map item array are copied
+*       into new map item array. In other words, copy can be thought as deep copy
+*       instead of just shallow copy of array pointer.
+*
+* @see CAlfModuleTestItem
+*/
+template< class T >
+NONSHARABLE_CLASS( TAlfModuleTestMap )
+{
+public:
+// Maximum item count in the map
+static const TInt KMaxArrayCount = 100;
+// Maximum accepted test type count in the map
+static const TInt KMaxAcceptArrayCount = 20;
+/**
+* Constructor to initialize variables.
+*/
+TAlfModuleTestMap():
+iArrayCount( 0 )
+{
+}
+/**
+* @note This will return normal items and also items that are links.
+*
+* @param aTestType Informs what type of test is accepted. Others are skipped.
+* @param aKey Key of the map item.
+* @return T* Ownership is not transferred.
+*            NULL if item is not found.
+*/
+TAlfModuleTestItem< T >* Find( const TAlfModuleTestType& aTestType, TInt aKey )
+{
+// Try to find the item corresponding the given key.
+for ( TInt i = 0; i < iArrayCount; ++i )
+{
+TAlfModuleTestItem< T >& testItem( iArray[ i ] );
+if ( testItem.Key() == aKey
+&& testItem.TestTypeMatch( aTestType ) )
+{
+return &( testItem );
+}
+}
+// Item corresponding the given key was not found.
+return NULL;
+}
+/**
+* Finds the actual item.
+*
+* @note If the given key identifies a link item,
+*       then search is continued to the actual item
+*       through the link chain.
+*       Link item is not returned here.
+*
+* @param aTestType Test type of the linked item and link item.
+* @param aKey Key of the item. This can also be a key to a link item.
+* @return TAlfModuleTestItem< T >* Actual item.
+*                                  NULL if item was not found.
+*                                  Ownership is not transferred.
+*/
+TAlfModuleTestItem< T >* FindActual( const TAlfModuleTestType& aTestType, TInt aKey )
+{
+TAlfModuleTestItem< T >* item( Find( aTestType, aKey ) );
+while ( item && item->LinkTargetKey() != KErrNotFound )
+{
+// Item is link.
+// So, find the actual item through link targets.
+item = Find( aTestType, item->LinkTargetKey() );
+}
+return item;
+}
+/**
+* Function to append new item into the map.
+*
+* @param aTestType Describes for what case the appended test item is created for.
+* @param aKey Key of the map item.
+* @param aDefaultValue Default value for the map item.
+* @return TInt System wide error code.
+*/
+TInt Append( const TAlfModuleTestType& aTestType, TInt aKey, const T& aDefaultValue )
+{
+if ( !Accept( aTestType ) )
+{
+// Given test type has not been set as accepted.
+return KErrNotSupported;
+}
+else if ( Find( aTestType, aKey ) )
+{
+// Item already exists in the map.
+return KErrAlreadyExists;
+}
+else if ( iArrayCount == KMaxArrayCount )
+{
+// Array already full.
+return KErrOverflow;
+}
+// Append new item into the array.
+iArray[ iArrayCount ] = TAlfModuleTestItem< T >( aTestType, aKey, aDefaultValue );
+++iArrayCount;
+return KErrNone;
+}
+/**
+* Creates and appends link item that links to another item.
+*
+* @param aTestType Test type of the linked item and link item.
+* @param aLinkKey Link item key.
+* @param aTargetKey Target item key.
+* @return TInt System wide error code.
+*/
+TInt AppendLink( const TAlfModuleTestType& aTestType, TInt aLinkKey, TInt aTargetKey )
+{
+if ( !Accept( aTestType ) )
+{
+// Given test type has not been set as accepted.
+return KErrNotSupported;
+}
+else if ( Find( aTestType, aLinkKey ) )
+{
+// Link item already exists in the map.
+return KErrAlreadyExists;
+}
+else if ( !FindActual( aTestType, aTargetKey ) )
+{
+// Link has to point to another existing item.
+// Also, link has to point to the chain that ends to actual item.
+// Then, links will not create forever loops. Loops could occur
+// if links in chain point to each other creating loops.
+return KErrNotFound;
+}
+else if ( iArrayCount == KMaxArrayCount )
+{
+// Array already full.
+return KErrOverflow;
+}
+// Create link item because original item exists and link chain is correct.
+// Append new link item into the array and link it to another link or to
+// actual item.
+TAlfModuleTestItem< T >* target( Find( aTestType, aTargetKey ) );
+// Set value of the link same as its target's value.
+iArray[ iArrayCount ] = TAlfModuleTestItem< T >( aTestType, aLinkKey, target->Value() );
+iArray[ iArrayCount ].SetLinkTargetKey( target->Key() );
+++iArrayCount;
+return KErrNone;
+}
+/**
+* Sets the value for the actual item.
+* Item itself should already appended into map and exist
+* in the array before setting its value here.
+*
+* @note Some items may be links. But, only the value of the
+*       actual item in the end of the link chain is set here.
+*
+* @param aTestType Describes for what case the item is for.
+* @param aKey Key of the map item.
+* @param aValue Value for the map item.
+* @return TInt System wide error code.
+*/
+TInt SetActualValue( const TAlfModuleTestType& aTestType, TInt aKey, const T& aValue )
+{
+TAlfModuleTestItem< T >* item( FindActual( aTestType, aKey ) );
+if ( !item )
+{
+// Actual item was not found from the array.
+return KErrNotFound;
+}
+// Actual item exists and it is not link item. So, set its values.
+item->SetValue( aValue );
+return KErrNone;
+}
+/**
+* Find an actual item if it exists and gets its value if item is found
+* and value has been set.
+*
+* @param aTestType Describes for what case the item is for.
+* @param aKey Key of the map item.
+* @param aValue If map item is found, value of the item is set here.
+* @return TBool ETrue if map item is found and value has been set. Else EFalse.
+*/
+TBool GetActualValue( const TAlfModuleTestType& aTestType, TInt aKey, T& aValue )
+{
+const TAlfModuleTestItem< T >* item( FindActual( aTestType, aKey ) );
+if ( item && item->ValueSetCount() > 0 )
+{
+aValue = item->Value();
+return ETrue;
+}
+return EFalse;
+}
+/**
+* Finds an actual item if it exists and checks if it equals the given value.
+*
+* @return TBool ETrue if item is found and its value equals given value. Else EFalse.
+*/
+TBool ActualEquals( const TAlfModuleTestType& aTestType, TInt aKey, const T& aValue )
+{
+T value( aValue );
+if ( GetActualValue( aTestType, aKey, value ) && value == aValue )
+{
+return ETrue;
+}
+return EFalse;
+}
+/**
+* @return TInt Number of map items
+*/
+TInt ItemCount() const
+{
+return iArrayCount;
+}
+/**
+* @return const TAlfModuleTestItem< T >& Reference to the map item
+*/
+const TAlfModuleTestItem< T >& Item( TInt aIndex ) const
+{
+return iArray[ aIndex ];
+}
+/**
+* Appends an accepted test type into the accepted array.
+*
+* @note Only items of accepted test type can be appended
+*       into this map.
+*
+* @param aTestType Test item type that is accepted for this map.
+* @return TInt System wide error code.
+*/
+TInt AppendAccept( const TAlfModuleTestType& aTestType )
+{
+if ( Accept( aTestType ) )
+{
+// Type already exists in the array.
+return KErrAlreadyExists;
+}
+else if ( iAcceptArrayCount == KMaxAcceptArrayCount )
+{
+// Array already full.
+return KErrOverflow;
+}
+iAcceptArray[ iAcceptArrayCount ] = aTestType;
+++iAcceptArrayCount;
+return KErrNone;
+}
+/**
+* @param aTestType Test item type to be checked.
+* @return TBool ETrue if given test type is set as accepted for this map.
+*               Else EFalse.
+*/
+TBool Accept( const TAlfModuleTestType& aTestType ) const
+{
+for ( TInt i = 0; i < iAcceptArrayCount; ++i )
+{
+if ( aTestType == iAcceptArray[ i ] )
+{
+return ETrue;
+}
+}
+return EFalse;
+}
+/**
+* Resets all the array items that match the given test type
+* to given default value.
+*
+* @param aTestType The test type of items that should be resetted.
+* @param aValue Reference to the value that items are resetted to.
+*/
+void ResetItems( const TAlfModuleTestType& aTestType, const T& aDefaultValue )
+{
+for ( TInt i = 0; i < iArrayCount; ++i )
+{
+if ( iArray[ i ].TestTypeMatch( aTestType ) )
+{
+iArray[ i ].Reset( aDefaultValue );
+}
+}
+}
+/**
+* Resets the map
+*/
+void Reset()
+{
+// Just reset the counter.
+// We do not bother to reset map items, because when counter is reseted
+// already set items and their info is left out of the scope.
+iArrayCount = 0;
+iAcceptArrayCount = 0;
+}
+private: // data
+TAlfModuleTestItem< T > iArray[ KMaxArrayCount ];
+TInt iArrayCount;
+TAlfModuleTestType iAcceptArray[ KMaxAcceptArrayCount ];
+TInt iAcceptArrayCount;
+};
+#endif // ALFMODULETESTMAP_H
+#endif // USE_MODULE_TEST_HOOKS_FOR_ALF
+// End of File

branch	RCL_3
changeset 7	88b23e2e82e1
child 8	46927d61fef3