--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uiacceltk/hitchcock/CommonInc/alfmoduletestmap.h Wed Mar 31 23:03:58 2010 +0300
@@ -0,0 +1,359 @@
+/**
+ * @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