--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/localconnectivityservice/generichid/tsrc/GenericHidTest/src/GenericHidTestBlocks.cpp Tue Aug 31 16:03:15 2010 +0300
@@ -0,0 +1,2839 @@
+/*
+* Copyright (c) 2008-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:
+*
+*/
+
+
+
+
+// [INCLUDE FILES] - do not remove
+#include <e32svr.h>
+#include <StifParser.h>
+#include <Stiftestinterface.h>
+#include "GenericHidTest.h"
+
+#include "hidreports.h"
+#include "tGenericHIDAPI.h"
+#include "tdialclient.h"
+#include "alarmcontrol.h"
+#include "timer.h"
+
+// EXTERNAL DATA STRUCTURES
+//extern ?external_data;
+
+// EXTERNAL FUNCTION PROTOTYPES
+//extern ?external_function( ?arg_type,?arg_type );
+
+// CONSTANTS
+//const ?type ?constant_var = ?constant;
+
+// MACROS
+//#define ?macro ?macro_def
+
+// LOCAL CONSTANTS AND MACROS
+//const ?type ?constant_var = ?constant;
+//#define ?macro_name ?macro_def
+
+// MODULE DATA STRUCTURES
+//enum ?declaration
+//typedef ?declaration
+
+// LOCAL FUNCTION PROTOTYPES
+//?type ?function_name( ?arg_type, ?arg_type );
+
+// FORWARD DECLARATIONS
+//class ?FORWARD_CLASSNAME;
+
+// ============================= LOCAL FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// ?function_name ?description.
+// ?description
+// Returns: ?value_1: ?description
+// ?value_n: ?description_line1
+// ?description_line2
+// -----------------------------------------------------------------------------
+//
+/*
+?type ?function_name(
+ ?arg_type arg, // ?description
+ ?arg_type arg) // ?description
+ {
+
+ ?code // ?comment
+
+ // ?comment
+ ?code
+ }
+*/
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::Delete
+// Delete here all resources allocated and opened from test methods.
+// Called from destructor.
+// -----------------------------------------------------------------------------
+//
+void CGenericHidTest::Delete()
+ {
+ if ( iGenericHIDTest )
+ {
+ delete iGenericHIDTest;
+ iGenericHIDTest = NULL;
+ }
+
+ if ( iDialClient )
+ {
+ delete iDialClient;
+ iDialClient = NULL;
+ }
+
+ if ( iAlarmControl )
+ {
+ delete iAlarmControl;
+ iAlarmControl = NULL;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::RunMethodL
+// Run specified method. Contains also table of test mothods and their names.
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::RunMethodL(
+ CStifItemParser& aItem )
+ {
+
+ static TStifFunctionInfo const KFunctions[] =
+ {
+ //ADD NEW ENTRY HERE
+ // [test cases entries] - Do not remove
+ ENTRY( "ExecuteApiTestBlock", CGenericHidTest::ExecuteApiTestBlock ),
+ ENTRY( "ExecuteModuleTestBlock", CGenericHidTest::ExecuteModuleTestBlock ),
+ ENTRY( "ExecuteBranchTestBlock", CGenericHidTest::ExecuteBranchTestBlock ),
+ };
+
+ const TInt count = sizeof( KFunctions ) /
+ sizeof( TStifFunctionInfo );
+
+ return RunInternalL( KFunctions, count, aItem );
+
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::GetTestBlockParamsL
+// -----------------------------------------------------------------------------
+
+void CGenericHidTest::GetTestBlockParamsL( CStifItemParser& aItem )
+ {
+ STIF_LOG( ">>> GetTestBlockParamsL" );
+
+ // Add new test block branches below, get all required test parameters
+ if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ExampleTestL" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption2 ) );
+ User::LeaveIfError( aItem.GetNextInt( iTestBlockParams.iTestIntOption1 ) );
+ User::LeaveIfError( aItem.GetNextChar( iTestBlockParams.iTestCharOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "Connect" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption2 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "Disconnect" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "DataIn" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption2 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "Wait" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ User::LeaveIfError( aItem.GetNextInt( iTestBlockParams.iTestIntOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CreateCall" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption2 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "AddAlarm" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ User::LeaveIfError( aItem.GetNextInt( iTestBlockParams.iTestIntOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "DeleteAlarm" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CountryCode" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "VendorId" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ProductId" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "SetProtocol" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "GetProtocol" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "GetReport" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "SetReport" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption2 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "DataOut" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption2 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "GetIdle" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "SetIdle" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CommandResult" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ReportDescriptor" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CreateReportGenerator" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "DeleteReportGenerator" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ReportGeneratorReport" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ReportGeneratorSetField" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption2 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CreateReportTranslator" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption2 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CreateReportTranslator_FieldNull" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption2 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CreateReportTranslator_NotArray" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption2 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CreateReportTranslator_FieldCountZero" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption2 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "DeleteReportTranslator" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ReportTranslatorGetValue" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption2 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ReportTranslatorValue" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ReportTranslatorGetUsageId" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption2 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ReportTranslatorUsageId" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ReportTranslatorRawValue" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ReportTranslatorCount" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption2 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "Collectiontype" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionIsPhysical" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionIsLogical" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionIsReport" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionIsNamedArray" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionIsUsageSwitch" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionIsUsageModifier" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionIsApplication" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionUsagePage" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionUsage" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionCollectionCount" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionFieldCount" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionCollectionByIndex" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption2 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionFieldByIndex" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ReportrootReportSizeBytes" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldLogicalMax" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldPhysicalMin" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldPhysicalMax" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldUnit" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldUnitExponent" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldCount" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSize" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldOffset" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption2 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldReportId" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldIsInReport" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldDesignatorIndex" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldStringIndex" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldUsagePage" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldHasUsage" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldUsageArray" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldUsage" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldUsageCount" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldClearUsageList" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldLastUsage" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption2 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldAttributes" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldType" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldIsVariable" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldIsArray" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldIsConstant" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldIsData" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetLogicalMin" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetLogicalMax" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetPhysicalMin" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetPhysicalMax" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetDesignatorMin" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetDesignatorMax" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetUsageMin" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetUsageMax" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetStringMin" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetStringMax" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetLogicalRange" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetUsageRange" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetPhysicalRange" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetStringRange" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetDesignatorRange" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldIsInput" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldIsOutput" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldIsFeature" ) ) )
+ {
+ User::LeaveIfError( aItem.GetNextString( iTestBlockParams.iTestOption1 ) );
+ }
+ else
+ {
+ STIF_LOG( "GetTestBlockParamsL, Test type: not found" );
+ User::Leave( KErrNotFound );
+ }
+ STIF_LOG( "<<< GetTestBlockParams" );
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::ExecuteApiTestBlock
+// -----------------------------------------------------------------------------
+
+TInt CGenericHidTest::ExecuteApiTestBlock( CStifItemParser& aItem )
+ {
+ STIF_LOG( ">>>ExecuteApiTestBlock" );
+
+ TInt res;
+ TGenericHidTestResult testResult;
+
+ TRAP( res, DoExecuteApiTestBlockL( aItem, testResult ) );
+ if ( res != KErrNone )
+ {
+ STIF_LOG1( "DoExecuteApiTestBlockL error: %d", res );
+ return res;
+ }
+
+ STIF_ASSERT_EQUALS( ETestCasePassed, testResult );
+ STIF_LOG( "Test case passed" );
+ STIF_LOG( "<<<ExecuteApiTestBlock" );
+
+ return KErrNone;
+ }
+
+
+void CGenericHidTest::DoExecuteApiTestBlockL( CStifItemParser& aItem, TGenericHidTestResult& aTestResult )
+ {
+ STIF_LOG( ">>>DoExecuteApiTestBlock" );
+
+ User::LeaveIfError( aItem.GetString( _L( "ExecuteApiTestBlock" ), iTestBlockParams.iTestBlockName ) );
+ STIF_LOG1( "Api test type: %S", &iTestBlockParams.iTestBlockName );
+
+ GetTestBlockParamsL( aItem );
+
+ // Add new API test block branches with optional test parameters here
+ if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ExampleTestL" ) ) )
+ {
+ ExampleTestL( iTestBlockParams.iTestOption1, iTestBlockParams.iTestOption2,
+ iTestBlockParams.iTestIntOption1, iTestBlockParams.iTestCharOption1, aTestResult );
+ }
+ else
+ {
+ STIF_LOG( "Test type: not found" );
+ User::Leave( KErrNotFound );
+ }
+
+ STIF_LOG( "<<<DoExecuteApiTestBlockL" );
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::ExecuteModuleTestBlock
+// -----------------------------------------------------------------------------
+
+TInt CGenericHidTest::ExecuteModuleTestBlock( CStifItemParser& aItem )
+ {
+ STIF_LOG( "[STIF_LOG] >>>ExecuteModuleTestBlock" );
+
+ TInt res;
+ TGenericHidTestResult testResult;
+
+ TRAP( res, DoExecuteModuleTestBlockL( aItem, testResult ) );
+ if ( res != KErrNone )
+ {
+ STIF_LOG1( "DoExecuteModuleTestBlockL error: %d", res );
+ return res;
+ }
+
+ STIF_ASSERT_EQUALS( ETestCasePassed, testResult );
+ STIF_LOG( "[STIF_LOG] Test case passed" );
+ STIF_LOG( "[STIF_LOG] <<<ExecuteModuleTestBlock" );
+ return KErrNone;
+ }
+
+
+void CGenericHidTest::DoExecuteModuleTestBlockL( CStifItemParser& aItem, TGenericHidTestResult& aTestResult )
+ {
+ STIF_LOG( "[STIF_LOG] >>>DoExecuteModuleTestBlockL" );
+
+ User::LeaveIfError( aItem.GetString( _L( "ExecuteModuleTestBlock" ), iTestBlockParams.iTestBlockName ) );
+ STIF_LOG1( "Module test type: %S", &iTestBlockParams.iTestBlockName );
+
+ GetTestBlockParamsL( aItem );
+
+ // Add new module test block branches with optional test parameters here
+ if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ExampleTestL" ) ) )
+ {
+ ExampleTestL( iTestBlockParams.iTestOption1, iTestBlockParams.iTestOption2,
+ iTestBlockParams.iTestIntOption1, iTestBlockParams.iTestCharOption1, aTestResult );
+ }
+ else
+ {
+ STIF_LOG( "Test type: not found" );
+ User::Leave( KErrNotFound );
+ }
+
+ STIF_LOG( "[STIF_LOG] <<<DoExecuteModuleTestBlockL" );
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::ExecuteBranchTestBlock
+// -----------------------------------------------------------------------------
+
+TInt CGenericHidTest::ExecuteBranchTestBlock( CStifItemParser& aItem )
+ {
+ STIF_LOG( "[STIF_LOG] >>>ExecuteBranchTestBlock" );
+
+ TInt res;
+ TGenericHidTestResult testResult = ETestCaseFailed;
+
+ TRAP( res, DoExecuteBranchTestBlockL( aItem, testResult ) );
+ if ( res != KErrNone )
+ {
+ STIF_LOG1( "DoExecuteBranchTestBlockL error: %d", res );
+ return res;
+ }
+
+ STIF_ASSERT_EQUALS( ETestCasePassed, testResult );
+ STIF_LOG( "[STIF_LOG] Test case passed" );
+ STIF_LOG( "[STIF_LOG] <<<ExecuteBranchTestBlock" );
+ return KErrNone;
+ }
+
+
+void CGenericHidTest::DoExecuteBranchTestBlockL( CStifItemParser& aItem, TGenericHidTestResult& aTestResult )
+ {
+ STIF_LOG( "[STIF_LOG] >>>DoExecuteBranchTestBlockL" );
+
+ User::LeaveIfError( aItem.GetString( _L( "ExecuteBranchTestBlock" ), iTestBlockParams.iTestBlockName ) );
+ STIF_LOG1( "Branch test type: %S", &iTestBlockParams.iTestBlockName );
+
+ GetTestBlockParamsL( aItem );
+
+ // Add new branch test block branches with optional test parameters here
+ if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ExampleTestL" ) ) )
+ {
+ ExampleTestL( iTestBlockParams.iTestOption1, iTestBlockParams.iTestOption2,
+ iTestBlockParams.iTestIntOption1, iTestBlockParams.iTestCharOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "Connect" ) ) )
+ {
+ ConnectL( iTestBlockParams.iTestOption1, iTestBlockParams.iTestOption2, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "Disconnect" ) ) )
+ {
+ DisconnectL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "DataIn" ) ) )
+ {
+ DataIn( iTestBlockParams.iTestOption1, iTestBlockParams.iTestOption2, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "Wait" ) ) )
+ {
+ WaitL( iTestBlockParams.iTestOption1, iTestBlockParams.iTestIntOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CreateCall" ) ) )
+ {
+ CreateCallL( iTestBlockParams.iTestOption1, iTestBlockParams.iTestOption2, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "AddAlarm" ) ) )
+ {
+ AddAlarmL( iTestBlockParams.iTestOption1, iTestBlockParams.iTestIntOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "DeleteAlarm" ) ) )
+ {
+ DeleteAlarm( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CountryCode" ) ) )
+ {
+ CountryCodeL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "VendorId" ) ) )
+ {
+ VendorIdL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ProductId" ) ) )
+ {
+ ProductIdL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "SetProtocol" ) ) )
+ {
+ SetProtocolL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "GetProtocol" ) ) )
+ {
+ GetProtocoL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "GetReport" ) ) )
+ {
+ GetReportL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "SetReport" ) ) )
+ {
+ SetReportL( iTestBlockParams.iTestOption1, iTestBlockParams.iTestOption2, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "DataOut" ) ) )
+ {
+ DataOutL( iTestBlockParams.iTestOption1, iTestBlockParams.iTestOption2, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "GetIdle" ) ) )
+ {
+ GetIdleL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "SetIdle" ) ) )
+ {
+ SetIdleL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CommandResult" ) ) )
+ {
+ CommandResultL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ReportDescriptor" ) ) )
+ {
+ ReportDescriptorL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CreateReportGenerator" ) ) )
+ {
+ CreateReportGeneratorL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "DeleteReportGenerator" ) ) )
+ {
+ DeleteReportGeneratorL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ReportGeneratorReport" ) ) )
+ {
+ ReportGeneratorReportL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ReportGeneratorSetField" ) ) )
+ {
+ ReportGeneratorSetFieldL( iTestBlockParams.iTestOption1, iTestBlockParams.iTestOption2, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CreateReportTranslator" ) ) )
+ {
+ CreateReportTranslatorL( iTestBlockParams.iTestOption1, iTestBlockParams.iTestOption2, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CreateReportTranslator_FieldNull" ) ) )
+ {
+ CreateReportTranslator_FieldNullL( iTestBlockParams.iTestOption1, iTestBlockParams.iTestOption2, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CreateReportTranslator_NotArray" ) ) )
+ {
+ CreateReportTranslator_NotArrayL( iTestBlockParams.iTestOption1, iTestBlockParams.iTestOption2, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CreateReportTranslator_FieldCountZero" ) ) )
+ {
+ CreateReportTranslator_FieldCountZeroL( iTestBlockParams.iTestOption1, iTestBlockParams.iTestOption2, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "DeleteReportTranslator" ) ) )
+ {
+ DeleteReportTranslatorL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ReportTranslatorGetValue" ) ) )
+ {
+ ReportTranslatorGetValueL( iTestBlockParams.iTestOption1, iTestBlockParams.iTestOption2, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ReportTranslatorValue" ) ) )
+ {
+ ReportTranslatorValueL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ReportTranslatorGetUsageId" ) ) )
+ {
+ ReportTranslatorGetUsageIdL( iTestBlockParams.iTestOption1, iTestBlockParams.iTestOption2, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ReportTranslatorUsageId" ) ) )
+ {
+ ReportTranslatorUsageIdL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ReportTranslatorRawValue" ) ) )
+ {
+ ReportTranslatorRawValueL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ReportTranslatorCount" ) ) )
+ {
+ ReportTranslatorCountL( iTestBlockParams.iTestOption1, iTestBlockParams.iTestOption2, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "Collectiontype" ) ) )
+ {
+ CollectiontypeL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionIsPhysical" ) ) )
+ {
+ CollectionIsPhysicalL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionIsLogical" ) ) )
+ {
+ CollectionIsLogicalL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionIsReport" ) ) )
+ {
+ CollectionIsReportL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionIsNamedArray" ) ) )
+ {
+ CollectionIsNamedArrayL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionIsUsageSwitch" ) ) )
+ {
+ CollectionIsUsageSwitchL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionIsUsageModifier" ) ) )
+ {
+ CollectionIsUsageModifierL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionIsApplication" ) ) )
+ {
+ CollectionIsApplicationL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionUsagePage" ) ) )
+ {
+ CollectionUsagePageL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionUsage" ) ) )
+ {
+ CollectionUsageL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionCollectionCount" ) ) )
+ {
+ CollectionFieldCountL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionFieldCount" ) ) )
+ {
+ CollectionFieldCountL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionCollectionByIndex" ) ) )
+ {
+ CollectionCollectionByIndexL( iTestBlockParams.iTestOption1, iTestBlockParams.iTestOption2, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "CollectionFieldByIndex" ) ) )
+ {
+ CollectionFieldByIndexL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "ReportrootReportSizeBytes" ) ) )
+ {
+ ReportrootReportSizeBytes( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldLogicalMax" ) ) )
+ {
+ FieldLogicalMaxL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldPhysicalMin" ) ) )
+ {
+ FieldPhysicalMinL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldPhysicalMax" ) ) )
+ {
+ FieldPhysicalMaxL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldUnit" ) ) )
+ {
+ FieldUnitL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldUnitExponent" ) ) )
+ {
+ FieldUnitExponentL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldCount" ) ) )
+ {
+ FieldCountL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSize" ) ) )
+ {
+ FieldSizeL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldOffset" ) ) )
+ {
+ FieldOffsetL( iTestBlockParams.iTestOption1, iTestBlockParams.iTestOption2, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldReportId" ) ) )
+ {
+ FieldReportIdL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldIsInReport" ) ) )
+ {
+ FieldIsInReportL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldDesignatorIndex" ) ) )
+ {
+ FieldDesignatorIndexL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldStringIndex" ) ) )
+ {
+ FieldStringIndexL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldUsagePage" ) ) )
+ {
+ FieldUsagePageL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldHasUsage" ) ) )
+ {
+ FieldHasUsageL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldUsageArray" ) ) )
+ {
+ FieldUsageArrayL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldUsage" ) ) )
+ {
+ FieldUsageL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldUsageCount" ) ) )
+ {
+ FieldUsageCountL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldClearUsageList" ) ) )
+ {
+ FieldClearUsageListL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldLastUsage" ) ) )
+ {
+ FieldLastUsageL( iTestBlockParams.iTestOption1, iTestBlockParams.iTestOption2, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldAttributes" ) ) )
+ {
+ FieldAttributesL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldType" ) ) )
+ {
+ FieldTypeL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldIsVariable" ) ) )
+ {
+ FieldIsVariableL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldIsArray" ) ) )
+ {
+ FieldIsArrayL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldIsConstant" ) ) )
+ {
+ FieldIsConstantL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldIsData" ) ) )
+ {
+ FieldIsDataL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetLogicalMin" ) ) )
+ {
+ FieldSetLogicalMinL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetLogicalMax" ) ) )
+ {
+ FieldSetPhysicalMinL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetPhysicalMin" ) ) )
+ {
+ FieldSetPhysicalMinL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetPhysicalMax" ) ) )
+ {
+ FieldSetPhysicalMaxL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetDesignatorMin" ) ) )
+ {
+ FieldSetDesignatorMinL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetDesignatorMax" ) ) )
+ {
+ FieldSetUsageMinL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetUsageMin" ) ) )
+ {
+ FieldSetUsageMinL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetUsageMax" ) ) )
+ {
+ FieldSetUsageMaxL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetStringMin" ) ) )
+ {
+ FieldSetStringMinL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetStringMax" ) ) )
+ {
+ FieldSetStringMaxL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetLogicalRange" ) ) )
+ {
+ FieldSetLogicalRangeL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetUsageRange" ) ) )
+ {
+ FieldSetUsageRangeL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetPhysicalRange" ) ) )
+ {
+ FieldSetPhysicalRangeL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetStringRange" ) ) )
+ {
+ FieldSetStringRangeL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldSetDesignatorRange" ) ) )
+ {
+ FieldSetDesignatorRangeL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldIsInput" ) ) )
+ {
+ FieldIsInputL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldIsOutput" ) ) )
+ {
+ FieldIsOutputL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else if ( !iTestBlockParams.iTestBlockName.Compare( _L( "FieldIsFeature" ) ) )
+ {
+ FieldIsFeatureL( iTestBlockParams.iTestOption1, aTestResult );
+ }
+ else
+ {
+ STIF_LOG( "DoExecuteBranchTestBlockL; Test type: not found" );
+ User::Leave( KErrNotFound );
+ }
+
+ STIF_LOG( "[STIF_LOG] <<<DoExecuteBranchTestBlock" );
+ }
+
+// Add test block methods implementation here
+// -----------------------------------------------------------------------------
+// CGenericHidTest::ExampleTestL
+// -----------------------------------------------------------------------------
+
+void CGenericHidTest::ExampleTestL( TPtrC aTestOption, TPtrC aTestSubOption,
+ TInt aTestIntOption, TInt aTestCharOption, TGenericHidTestResult& aTestResult )
+ {
+ STIF_LOG( ">>>ExampleTest" );
+
+ if ( !aTestOption.Compare( _L( "API" ) ) )
+ {
+ STIF_LOG1( "Api test option: %S", &aTestOption );
+ STIF_LOG1( "Api test sub-option: %S", &aTestSubOption );
+ STIF_LOG1( "Api test int option: %d", aTestIntOption );
+ STIF_LOG1( "Api test char option: %c", aTestCharOption );
+ }
+ else if ( !aTestOption.Compare( _L( "MODULE" ) ) )
+ {
+ STIF_LOG1( "Module test option: %S", &aTestOption );
+ STIF_LOG1( "Module test sub-option: %S", &aTestSubOption );
+ STIF_LOG1( "Module test int option: %d", aTestIntOption );
+ STIF_LOG1( "Module test char option: %c", aTestCharOption );
+ }
+ else if ( !aTestOption.Compare( _L( "BRANCH" ) ) )
+ {
+ STIF_LOG1( "Branch test option: %S", &aTestOption );
+ STIF_LOG1( "Branch test sub-option: %S", &aTestSubOption );
+ STIF_LOG1( "Branch test int option: %d", aTestIntOption );
+ STIF_LOG1( "Branch test char option: %c", aTestCharOption );
+ }
+ else
+ {
+ STIF_LOG( "Invalid test parameter" );
+ User::Leave( KErrNotFound );
+ }
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "<<<ExampleTest" );
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::ConnectL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::ConnectL( TPtrC aTestOption, TPtrC aTestSubOption, TGenericHidTestResult& aTestResult )
+ {
+ STIF_LOG( "Connect" );
+
+ if ( !iGenericHIDTest )
+ {
+ iGenericHIDTest = CtGenericHIDAPI::NewL();
+ }
+ HBufC8* report = ConvertArray(aTestSubOption);
+
+ CleanupStack::PushL( report );
+ iGenericHIDTest->ConnectL(0,*report);
+ CleanupStack::PopAndDestroy();
+
+ STIF_LOG( "Connect passed" );
+
+ aTestResult = ETestCasePassed;
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::DisconnectL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::DisconnectL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->DisconnectL(0);
+ delete iGenericHIDTest;
+ iGenericHIDTest = NULL;
+
+ STIF_LOG( "Disconnect passed" );
+
+ aTestResult = ETestCasePassed;
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::DataIn
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::DataIn( TPtrC aTestOption, TPtrC aTestSubOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt retVal = KErrNone;
+ HBufC8* report = ConvertArray(aTestSubOption);
+ TInt firstByte = (*report)[0];
+ STIF_LOG1("aTestSubOption >> report: %d", firstByte);
+
+ retVal = iGenericHIDTest->DataInL(0,*report);
+ STIF_LOG1( "DataInL return value: %d" , retVal);
+
+ delete report;
+ report = NULL;
+
+ STIF_LOG( "Test case passed" );
+
+ aTestResult = ETestCasePassed;
+
+ return retVal;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::Wait
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::WaitL( TPtrC aTestOption, TInt aTestIntOption, TGenericHidTestResult& aTestResult )
+ {
+ CWaitTimer* timer = CWaitTimer::NewLC(aTestIntOption * 1000000);
+ CleanupStack::PopAndDestroy(timer);
+
+ STIF_LOG( "Test case passed" );
+
+ aTestResult = ETestCasePassed;
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::CreateCallL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::CreateCallL( TPtrC aTestOption, TPtrC aTestSubOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt err = KErrNone;
+
+ if ( iDialClient )
+ {
+ delete iDialClient;
+ iDialClient = NULL;
+ }
+ iDialClient = CDialClient::NewL();
+
+ iDialClient->CreateCall( aTestSubOption );
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::AddAlarm
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::AddAlarmL( TPtrC aTestOption, TInt aTestIntOption, TGenericHidTestResult& aTestResult )
+ {
+ STIF_LOG( ">>AddAlarmL" );
+
+ if ( !iAlarmControl )
+ {
+ iAlarmControl = CAlarmControl::NewL( iLog );
+ }
+
+ STIF_LOG( "Create alarm" );
+
+ iAlarmControl->CreateClockAlarm( aTestIntOption );
+
+ STIF_LOG( "Test case passed" );
+
+ aTestResult = ETestCasePassed;
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::DeleteAlarm
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::DeleteAlarm( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iAlarmControl->DeleteAlarm();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::CountryCodeL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::CountryCodeL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->RunCountryCodeL();
+ STIF_LOG2( "RunCountryCodeL return value: %d, expected: %d", ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::VendorIdL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::VendorIdL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->RunVendorIdL();
+ STIF_LOG2( "RunVendorIdL return value: %d, expected: %d", ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::ProductIdL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::ProductIdL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->RunProductIdL();
+ STIF_LOG2( "RunProductIdL return value: %d, expected: %d", ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::SetProtocol
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::SetProtocolL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->RunSetProtocolL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::GetProtocoL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::GetProtocoL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->RunGetProtocoL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::GetReportL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::GetReportL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->RunGetReportL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::SetReportL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::SetReportL( TPtrC aTestOption, TPtrC aTestSubOption, TGenericHidTestResult& aTestResult )
+ {
+ HBufC8* report = ConvertArray(aTestSubOption);
+ CleanupStack::PushL( report );
+ iGenericHIDTest->RunSetReportL( *report );
+ CleanupStack::PopAndDestroy();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::DataOutL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::DataOutL( TPtrC aTestOption, TPtrC aTestSubOption, TGenericHidTestResult& aTestResult )
+ {
+ HBufC8* report = ConvertArray(aTestSubOption);
+ CleanupStack::PushL( report );
+ iGenericHIDTest->RunDataOutL( *report );
+ CleanupStack::PopAndDestroy();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::GetIdleL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::GetIdleL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->GetGetIdleL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::SetIdleL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::SetIdleL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->RunSetIdleL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+// -----------------------------------------------------------------------------
+// CGenericHidTest::CommandResultL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::CommandResultL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->GetCommandResultL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+// -----------------------------------------------------------------------------
+// CGenericHidTest::ReportDescriptorL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::ReportDescriptorL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->GetReportDescriptorL();
+ STIF_LOG2( "GetReportDescriptorL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::ReportDescriptorL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::CreateReportGeneratorL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->CreateReportGeneratorL();
+ STIF_LOG2( "CreateReportGeneratorL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::ReportDescriptorL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::DeleteReportGeneratorL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->DeleteReportGeneratorL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::ReportDescriptorL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::ReportGeneratorReportL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->ReportGeneratorReport();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::ReportGeneratorSetFieldL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::ReportGeneratorSetFieldL( TPtrC aTestOption, TPtrC aTestSubOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret;
+ TInt expectedResult = KErrNone;
+
+ if ( !aTestSubOption.Compare( _L( "Array" ) ) )
+ {
+ iLog -> Log( _L("Test type: Array") );
+ ret = iGenericHIDTest->ReportGeneratorSetFieldL( ETrue, EFalse, EFalse, EFalse, ETrue, EFalse );
+ }
+ else if ( !aTestSubOption.Compare( _L( "NotArray" ) ) )
+ {
+ iLog -> Log( _L("Test type: NotArray") );
+ ret = iGenericHIDTest->ReportGeneratorSetFieldL( EFalse, EFalse, EFalse, EFalse, ETrue, EFalse );
+ }
+ else if ( !aTestSubOption.Compare( _L( "NotArrayOutOfRange" ) ) )
+ {
+ iLog -> Log( _L("Test type: NotArrayOutOfRange") );
+ ret = iGenericHIDTest->ReportGeneratorSetFieldL( EFalse, ETrue, EFalse, EFalse, ETrue, EFalse );
+ expectedResult = KErrValueOutOfRange;
+ }
+ else if ( !aTestSubOption.Compare( _L( "FieldNull" ) ) )
+ {
+ iLog -> Log( _L("Test type: FieldNull") );
+ ret = iGenericHIDTest->ReportGeneratorSetFieldL( EFalse, EFalse, ETrue, EFalse, ETrue, EFalse );
+ expectedResult = KErrUsageNotFound;
+ }
+ else if ( !aTestSubOption.Compare( _L( "FieldCountZero" ) ) )
+ {
+ iLog -> Log( _L("Test type: FieldCountZero") );
+ ret = iGenericHIDTest->ReportGeneratorSetFieldL( ETrue, EFalse, EFalse, ETrue, ETrue, EFalse );
+ expectedResult = KErrNoSpaceInArray;
+ }
+ else if ( !aTestSubOption.Compare( _L( "NotExistingUsage" ) ) )
+ {
+ iLog -> Log( _L("Test type: NotExistingUsage") );
+ ret = iGenericHIDTest->ReportGeneratorSetFieldL( ETrue, EFalse, EFalse, ETrue, EFalse, EFalse );//getIndexOfUsage
+ expectedResult = KErrUsageNotFound;
+ }
+ else if ( !aTestSubOption.Compare( _L( "NotExistingUsage2" ) ) )
+ {
+ iLog -> Log( _L("Test type: NotExistingUsage2") );
+ ret = iGenericHIDTest->ReportGeneratorSetFieldL( ETrue, EFalse, EFalse, EFalse, EFalse, EFalse );//getIndexOfUsage
+ expectedResult = KErrUsageNotFound;
+ }
+ else if ( !aTestSubOption.Compare( _L( "BadIndex" ) ) )
+ {
+ iLog -> Log( _L("Test type: BadIndex") );
+ ret = iGenericHIDTest->ReportGeneratorSetFieldL( EFalse, EFalse, EFalse, EFalse, ETrue, ETrue );
+ expectedResult = KErrBadControlIndex;
+ }
+ else
+ {
+ iLog -> Log( _L("Test type: not supported") );
+ return KErrNotFound;
+ }
+
+
+ STIF_LOG2( "ReportGeneratorSetFieldL return value: %d, expected: %d" , ret, expectedResult);
+ STIF_ASSERT_EQUALS(ret, expectedResult);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::CreateReportTranslatorL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::CreateReportTranslatorL( TPtrC aTestOption, TPtrC aTestSubOption, TGenericHidTestResult& aTestResult )
+ {
+ HBufC8* report = ConvertArray(aTestSubOption);
+ CleanupStack::PushL( report );
+ iGenericHIDTest->CreateReportTranslatorL( *report , ETrue, EFalse, EFalse);
+ CleanupStack::PopAndDestroy();
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::CreateReportTranslator_FieldNullL( TPtrC aTestOption, TPtrC aTestSubOption, TGenericHidTestResult& aTestResult )
+ {
+ HBufC8* report = ConvertArray(aTestSubOption);
+ CleanupStack::PushL( report );
+ iGenericHIDTest->CreateReportTranslatorL( *report, EFalse, ETrue, EFalse );
+ CleanupStack::PopAndDestroy();
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::CreateReportTranslator_NotArrayL( TPtrC aTestOption, TPtrC aTestSubOption, TGenericHidTestResult& aTestResult )
+ {
+ HBufC8* report = ConvertArray(aTestSubOption);
+ CleanupStack::PushL( report );
+ iGenericHIDTest->CreateReportTranslatorL( *report , EFalse, EFalse, EFalse);
+ CleanupStack::PopAndDestroy();
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::CreateReportTranslator_FieldCountZeroL( TPtrC aTestOption, TPtrC aTestSubOption, TGenericHidTestResult& aTestResult )
+ {
+ HBufC8* report = ConvertArray(aTestSubOption);
+ CleanupStack::PushL( report );
+ iGenericHIDTest->CreateReportTranslatorL( *report , ETrue, EFalse, ETrue);
+ CleanupStack::PopAndDestroy();
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::DeleteReportTranslatorL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::DeleteReportTranslatorL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->DeleteReportTranslatorL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::ReportTranslatorGetValueL( TPtrC aTestOption, TPtrC aTestSubOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret;
+ TInt expectedResult = KErrNone;
+
+ if ( !aTestSubOption.Compare( _L( "Ok" ) ) )
+ {
+ iLog -> Log( _L("Test type: Ok") );
+ }
+ else if ( !aTestSubOption.Compare( _L( "NotFound" ) ) )
+ {
+ iLog -> Log( _L("Test type: NotFound") );
+ expectedResult = KErrUsageNotFound;
+ }
+ else
+ {
+ iLog -> Log( _L("Test type: not supported") );
+ return KErrNotFound;
+ }
+
+ ret = iGenericHIDTest->ReportTranslatorGetValueL();
+ STIF_LOG2( "ReportTranslatorGetValueL return value: %d, expected: %d" , ret, expectedResult);
+ STIF_ASSERT_EQUALS(ret, expectedResult);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::ReportTranslatorValueL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::ReportTranslatorValueL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->ReportTranslatorValueL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::ReportTranslatorGetUsageIdL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::ReportTranslatorGetUsageIdL( TPtrC aTestOption, TPtrC aTestSubOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret;
+ TInt expectedResult = KErrNone;
+ TInt badIndex = EFalse;
+
+ if ( !aTestSubOption.Compare( _L( "Ok" ) ) )
+ {
+ iLog -> Log( _L("Test type: Ok") );
+ }
+ else if ( !aTestSubOption.Compare( _L( "Error" ) ) )
+ {
+ iLog -> Log( _L("Test type: Error") );
+ expectedResult = KErrNoMemory;
+ }
+ else if ( !aTestSubOption.Compare( _L( "BadIndex" ) ) )
+ {
+ iLog -> Log( _L("Test type: BadIndex") );
+ badIndex = ETrue;
+ expectedResult = KErrBadControlIndex;
+ }
+ else
+ {
+ iLog -> Log( _L("Test type: not supported") );
+ return KErrNotFound;
+ }
+
+ ret = iGenericHIDTest->ReportTranslatorGetUsageIdL( badIndex );
+ STIF_LOG2( "ReportTranslatorGetUsageIdL return value: %d, expected: %d" , ret, expectedResult);
+ STIF_ASSERT_EQUALS(ret, expectedResult);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::ReportTranslatorUsageIdL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::ReportTranslatorUsageIdL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->ReportTranslatorUsageIdL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::ReportTranslatorRawValueL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::ReportTranslatorRawValueL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->ReportTranslatorRawValueL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::ReportTranslatorCountL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::ReportTranslatorCountL( TPtrC aTestOption, TPtrC aTestSubOption, TGenericHidTestResult& aTestResult)
+ {
+ TInt zeroExpected = EFalse;
+
+ if ( !aTestSubOption.Compare( _L( "Zero" ) ) )
+ {
+ iLog -> Log( _L("Test type: Zero") );
+ zeroExpected = ETrue;
+ }
+ else if ( !aTestSubOption.Compare( _L( "NotZero" ) ) )
+ {
+ iLog -> Log( _L("Test type: NotZero") );
+ }
+ else
+ {
+ iLog -> Log( _L("Test type: not supported") );
+ return KErrNotFound;
+ }
+
+ TInt count = iGenericHIDTest->ReportTranslatorCountL();
+
+ STIF_LOG1( "ReportTranslatorCountL return value: %d" , count);
+ if(zeroExpected != EFalse)
+ {
+ STIF_ASSERT_EQUALS(0, count)
+ }
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::CollectiontypeL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::CollectiontypeL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->CollectiontypeL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::CollectionIsPhysicalL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::CollectionIsPhysicalL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->CollectionIsPhysicalL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::CollectionIsLogicalL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::CollectionIsLogicalL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->CollectionIsLogicalL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::CollectionIsReportL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::CollectionIsReportL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->CollectionIsReportL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::CollectionIsNamedArrayL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::CollectionIsNamedArrayL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->CollectionIsNamedArrayL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+// -----------------------------------------------------------------------------
+// CGenericHidTest::CollectionIsUsageSwitchL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::CollectionIsUsageSwitchL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->CollectionIsUsageSwitchL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::CollectionIsUsageModifierL
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::CollectionIsUsageModifierL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->CollectionIsUsageModifierL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::CollectionIsApplicationL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->CollectionIsApplicationL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+
+TInt CGenericHidTest::CollectionUsagePageL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->CollectionUsagePageL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::CollectionUsageL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->CollectionUsageL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::CollectionCollectionCountL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->CollectionCollectionCountL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::CollectionFieldCountL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->CollectionFieldCountL();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::CollectionCollectionByIndexL( TPtrC aTestOption, TPtrC aTestSubOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret;
+
+ if ( !aTestSubOption.Compare( _L( "Present" ) ) )
+ {
+ iLog -> Log( _L("Test type: Present") );
+ ret = iGenericHIDTest->CollectionCollectionByIndexL(ETrue);
+ }
+ else if ( !aTestSubOption.Compare( _L( "NotPresent" ) ) )
+ {
+ iLog -> Log( _L("Test type: NotPresent") );
+ ret = iGenericHIDTest->CollectionCollectionByIndexL(EFalse);
+ }
+ else
+ {
+ iLog -> Log( _L("Test type: not supported") );
+ return KErrNotFound;
+ }
+
+ STIF_LOG2( "CollectionCollectionByIndexL return value: %d, expected: %d", ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::CollectionFieldByIndexL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->CollectionFieldByIndexL();
+ STIF_LOG2( "CollectionFieldByIndexL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::ReportrootReportSizeBytes
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::ReportrootReportSizeBytes( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ iGenericHIDTest->ReportrootReportSizeBytes();
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+// -----------------------------------------------------------------------------
+// CGenericHidTest::FieldLogicalMax
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::FieldLogicalMaxL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldLogicalMaxL();
+ STIF_LOG2( "FieldLogicalMaxL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+// -----------------------------------------------------------------------------
+// CGenericHidTest::FieldPhysicalMin
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::FieldPhysicalMinL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldPhysicalMinL();
+ STIF_LOG2( "FieldPhysicalMinL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+// -----------------------------------------------------------------------------
+// CGenericHidTest::FieldPhysicalMax
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::FieldPhysicalMaxL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldPhysicalMaxL();
+ STIF_LOG2( "FieldPhysicalMaxL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+// -----------------------------------------------------------------------------
+// CGenericHidTest::FieldUnit
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::FieldUnitL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldUnitL();
+ STIF_LOG2( "FieldUnitL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+// -----------------------------------------------------------------------------
+// CGenericHidTest::FieldUnitExponent
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::FieldUnitExponentL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldUnitExponentL();
+ STIF_LOG2( "FieldUnitExponentL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldCountL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldCountL();
+ STIF_LOG2( "FieldCountL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldSizeL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldSizeL();
+ STIF_LOG2( "FieldSizeL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldOffsetL( TPtrC aTestOption, TPtrC aTestSubOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret;
+
+ if ( !aTestSubOption.Compare( _L( "SetReport" ) ) )
+ {
+ iLog -> Log( _L("Test type: SetReport") );
+ ret = iGenericHIDTest->FieldOffsetL(ETrue);
+ }
+ else if ( !aTestSubOption.Compare( _L( "NotSetReport" ) ) )
+ {
+ iLog -> Log( _L("Test type: NotSetReport") );
+ ret = iGenericHIDTest->FieldOffsetL(EFalse);
+ }
+ else
+ {
+ iLog -> Log( _L("Test type: not supported") );
+ return KErrNotFound;
+ }
+
+ STIF_LOG2( "FieldOffsetL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldReportIdL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldReportIdL();
+ STIF_LOG2( "FieldReportIdL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldIsInReportL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldIsInReportL();
+ STIF_LOG2( "FieldIsInReportL return value: %d, expected: %d", ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldDesignatorIndexL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldDesignatorIndexL();
+ STIF_LOG2( "FieldDesignatorIndexL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldStringIndexL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldStringIndexL();
+ STIF_LOG2( "FieldStringIndexL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldUsagePageL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldUsagePageL();
+ STIF_LOG2( "FieldUsagePageL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::FieldHasUsage
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::FieldHasUsageL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldHasUsageL();
+ STIF_LOG2( "FieldHasUsageL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldUsageArrayL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldUsageArrayL();
+ STIF_LOG2( "FieldUsageArrayL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldUsageL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldUsageL();
+ STIF_LOG2( "FieldUsageL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldUsageCountL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldUsageCountL();
+ STIF_LOG2( "FieldUsageCountL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldClearUsageListL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldClearUsageListL();
+ STIF_LOG2( "FieldClearUsageListL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldLastUsageL( TPtrC aTestOption, TPtrC aTestSubOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret;
+
+ if ( !aTestSubOption.Compare( _L( "Empty" ) ) )
+ {
+ iLog -> Log( _L("Test type: Empty") );
+ ret = iGenericHIDTest->FieldLastUsageL( ETrue );
+ }
+ else if ( !aTestSubOption.Compare( _L( "NotEmpty" ) ) )
+ {
+ iLog -> Log( _L("Test type: NotEmpty") );
+ ret = iGenericHIDTest->FieldLastUsageL( EFalse );
+ }
+ else
+ {
+ iLog -> Log( _L("Test type: not supported") );
+ return KErrNotFound;
+ }
+
+ STIF_LOG2( "FieldLastUsageL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::FieldAttributes
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::FieldAttributesL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldAttributesL();
+ STIF_LOG2( "FieldAttributesL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::FieldType
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::FieldTypeL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldTypeL();
+ STIF_LOG2( "FieldTypeL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::FieldIsVariable
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::FieldIsVariableL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldIsVariableL();
+ STIF_LOG2( "FieldIsVariableL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldIsArrayL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldIsArrayL();
+ STIF_LOG2( "FieldIsArrayL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::FieldIsConstant
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::FieldIsConstantL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldIsConstantL();
+ STIF_LOG2( "FieldIsConstantL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldIsDataL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldIsDataL();
+ STIF_LOG2( "FieldIsDataL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::FieldSetLogicalMin
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::FieldSetLogicalMinL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldSetLogicalMinL();
+ STIF_LOG2( "FieldSetLogicalMinL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::FieldSetLogicalMax
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::FieldSetLogicalMaxL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldSetLogicalMaxL();
+ STIF_LOG2( "FieldSetLogicalMaxL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::FieldSetPhysicalMin
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::FieldSetPhysicalMinL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldSetPhysicalMinL();
+ STIF_LOG2( "FieldSetPhysicalMinL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::FieldSetPhysicalMax
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::FieldSetPhysicalMaxL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldSetPhysicalMaxL();
+ STIF_LOG2( "FieldSetPhysicalMaxL return value: %d, expected: %d", ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::FieldSetDesignatorMin
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::FieldSetDesignatorMinL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldSetDesignatorMinL();
+ STIF_LOG2( "FieldSetDesignatorMinL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+// -----------------------------------------------------------------------------
+// CGenericHidTest::FieldSetDesignatorMax
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::FieldSetDesignatorMaxL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldSetDesignatorMaxL();
+ STIF_LOG2( "FieldSetDesignatorMaxL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldSetUsageMinL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldSetUsageMinL();
+ STIF_LOG2( "FieldSetUsageMinL return value: %d, expected: %d" , ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldSetUsageMaxL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldSetUsageMaxL();
+ STIF_LOG2( "FieldSetUsageMaxL return value: %d, expected: %d", ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::FieldSetStringMin
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::FieldSetStringMinL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldSetStringMinL();
+ STIF_LOG2( "FieldSetStringMinL return value: %d, expected: %d", ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::FieldSetStringMax
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::FieldSetStringMaxL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldSetStringMaxL();
+ STIF_LOG2( "FieldSetStringMaxL return value: %d, expected: %d", ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldSetLogicalRangeL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldSetLogicalRangeL();
+ STIF_LOG2( "FieldSetLogicalRangeL return value: %d, expected: %d", ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldSetUsageRangeL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldSetUsageRangeL();
+ STIF_LOG2( "FieldSetUsageRangeL return value: %d, expected: %d", ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldSetPhysicalRangeL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldSetPhysicalRangeL();
+ STIF_LOG2( "FieldSetPhysicalRangeL return value: %d, expected: %d", ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldSetStringRangeL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldSetStringRangeL();
+ STIF_LOG2( "FieldSetStringRangeL return value: %d, expected: %d", ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldSetDesignatorRangeL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldSetDesignatorRangeL();
+ STIF_LOG2( "FieldSetDesignatorRangeL return value: %d, expected: %d", ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+TInt CGenericHidTest::FieldIsInputL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldIsInputL();
+ STIF_LOG2( "FieldIsInputL return value: %d, expected: %d", ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::FieldIsOutput
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::FieldIsOutputL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldIsOutputL();
+ STIF_LOG2( "FieldIsOutputL return value: %d, expected: %d", ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::FieldIsFeature
+// -----------------------------------------------------------------------------
+//
+TInt CGenericHidTest::FieldIsFeatureL( TPtrC aTestOption, TGenericHidTestResult& aTestResult )
+ {
+ TInt ret = iGenericHIDTest->FieldIsFeatureL();
+ STIF_LOG2( "FieldIsFeatureL return value: %d, expected: %d", ret, KErrNone);
+ STIF_ASSERT_EQUALS(ret, KErrNone);
+
+ aTestResult = ETestCasePassed;
+
+ STIF_LOG( "Test case passed" );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::ConvSingleItem
+// -----------------------------------------------------------------------------
+//
+TUint CGenericHidTest::ConvSingleItem(TBuf8<2>& singleItem)
+ {
+ TLex8 lex(singleItem);
+ TUint value;
+ lex.Val(value,EHex);
+ singleItem.Delete(0,2);
+ return value;
+ }
+
+// -----------------------------------------------------------------------------
+// CGenericHidTest::ConvertArray
+// -----------------------------------------------------------------------------
+//
+HBufC8* CGenericHidTest::ConvertArray( const TPtrC& aFilename )
+ {
+ RFs theFs;
+
+ RFile someFile;
+ if(theFs.Connect() != KErrNone)
+ {
+ return NULL;
+ }
+ TInt error = someFile.Open(theFs, aFilename, EFileShareExclusive);
+
+ RArray<TUint> arrDesc;
+ if (!error)
+ {
+ TBool seekEOL = EFalse;
+ TBuf8<2> singleItem;
+
+ TInt hexByte = 0;
+
+ TBool bTerminator = EFalse;
+
+ TBuf8<1> oneChar;
+ someFile.Read(oneChar, 1);
+
+ while ( (!error) && (oneChar.Size()) )
+ {
+ switch ( oneChar[0] )
+ {
+ case 10:
+ case 13:
+ seekEOL = EFalse;
+ break;
+
+ case '/':
+ seekEOL = ETrue;
+ // Comments are special case terminators
+ // interntional drop through to the next case line
+ case ' ':
+ case '\t':
+ case ',':
+ // whitespace - ignore, unless we've started storing a value
+ // (in which case treat the char as a terminator)
+ bTerminator = ETrue;
+ break;
+
+ default:
+ if (!seekEOL)
+ {
+ if (4==hexByte)
+ {
+ error = KErrGeneral; // Can't store more than two digits
+ }
+ else if (hexByte>1)
+ {
+ singleItem.Append(oneChar);
+ }
+
+ hexByte++;
+ }
+ break;
+ }
+
+ if ( bTerminator && singleItem.Size() )
+ {
+ TUint value = ConvSingleItem(singleItem);
+ arrDesc.Append(value);
+ hexByte = 0;
+ }
+
+ bTerminator = EFalse;
+
+ someFile.Read(oneChar, 1);
+ }
+
+ if (singleItem.Size())
+ {
+ TUint value = ConvSingleItem(singleItem);
+ arrDesc.Append(value);
+ }
+
+ someFile.Close();
+ }
+
+ theFs.Close();
+
+ HBufC8* theDesc = 0;
+
+ if (!error)
+ {
+ TInt size = arrDesc.Count();
+ TRAPD( error, theDesc = HBufC8::NewL(size) );
+ if ( error != KErrNone )
+ {
+ return NULL;
+ }
+ TPtr8 des = theDesc->Des();
+ for(TInt x=0; x<size; x++)
+ {
+ des.Append(TUint8(arrDesc[x]));
+ }
+ }
+ arrDesc.Close();
+ return theDesc;
+ }
+// ========================== OTHER EXPORTED FUNCTIONS =========================
+// None
+
+// [End of File] - Do not remove