diff -r 000000000000 -r a41df078684a kerneltest/e32test/digitiser/t_ldddigitisertest.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/kerneltest/e32test/digitiser/t_ldddigitisertest.cpp Mon Oct 19 15:55:17 2009 +0100 @@ -0,0 +1,405 @@ +// 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 the License "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: +// e32test\digitiser\t_ldddigitisertest.cpp +// +// + +#include +#include +#include "d_lddDigitisertest.h" +#include + +_LIT(KLddFileName, "D_LDDDIGITISERTEST.LDD"); + +RLddDigitiserTest gLDD; +GLDEF_D RTest test(_L("Digitiser LDD tests")); + +void DoTestOnUnregisteredDevice() + { + __UHEAP_MARK; + test.Printf(_L("DoTestOnUnregisteredDevice(): should return KErrNotSupported coz NO DEVICE IS REGISTERED !!!")); + TInt r; + TInt halApiVal; + TInt unregisteredDeviceNumber=99; // Its highly unlikely that this device number is registered + + r=HAL::Get(unregisteredDeviceNumber,HALData::EPointer3D,halApiVal); + test(r==KErrNotSupported); + + r=HAL::Get(unregisteredDeviceNumber,HALData::EPointer3DMaxProximity,halApiVal); + test(r==KErrNotSupported); + + r=HAL::Get(unregisteredDeviceNumber,HALData::EPointer3DThetaSupported,halApiVal); + test(r==KErrNotSupported); + + r=HAL::Get(unregisteredDeviceNumber,HALData::EPointer3DPhiSupported,halApiVal); + test(r==KErrNotSupported); + + r=HAL::Get(unregisteredDeviceNumber,HALData::EPointer3DRotationSupported,halApiVal); + test(r==KErrNotSupported); + + r=HAL::Get(unregisteredDeviceNumber,HALData::EPointer3DPressureSupported,halApiVal); + test(r==KErrNotSupported); + + r=HAL::Get(unregisteredDeviceNumber,HALData::EPointer3DProximityStep,halApiVal); + test(r==KErrNotSupported); + + r=HAL::Get(unregisteredDeviceNumber,HALData::EPointerMaxPointers,halApiVal); + test(r==KErrNotSupported); + + r=HAL::Get(unregisteredDeviceNumber,HALData::EPointerNumberOfPointers,halApiVal); + test(r==KErrNotSupported); + + r=HAL::Get(unregisteredDeviceNumber,HALData::EPointer3DMaxPressure,halApiVal); + test(r==KErrNotSupported); + + r=HAL::Get(unregisteredDeviceNumber,HALData::EPointer3DPressureStep,halApiVal); + test(r==KErrNotSupported); + + test.Printf(_L("Successully Finished Testing the DoTestOnUnregisteredDevice\n")); + __UHEAP_MARKEND; + } + +void DoTestDerivedeAtributes() + { + __UHEAP_MARK; + TInt r; + TInt halApiVal; + TInt testDriverVal; + TInt testDeviceNumber; + + //new Values for HAL::Set + TInt halPointer3DMaxProximity=45; + TInt halPointerNumberOfPointers=5; + + // New attribute values for Driver APIs + TInt newPointer3D=0; + TInt newPointer3DMaxProximity=50; + TInt newPointer3DThetaSupported=0; + TInt newPointer3DPhiSupported=0; + TInt newPointer3DRotationSupported=0; + TInt newPointer3DPressureSupported=0; + TInt newPointer3DProximityStep=6; + TInt newPointerMaxPointers=7; + TInt newPointerNumberOfPointers=2; + TInt newPointer3DMaxPressure=501; + TInt newPointer3DPressureStep=50; + +/* +The following sequence should be followed + +a) Load the test Driver + +b) Open the channel + +c) Register Kernel Hal Handler + +d) Get the Registered Device Number + +e) Initialise HAL data + +f) Get/Set HAL Data using HAL APIS (HAL::GET, HAL::SET) + +g) Get/Set the HAL data throught the test driver APIS + +h) Compare the results and make sure that data recived are same and data set + using HAL library apis received with test driver APIS and vice versa. + +i) Do it for all the new Digitiser Attributes (11 at the moment) + +j) ..... + +k) De-register the Kernel HAL handler + +l) Unload the Driver + +m) END... + +*/ + test.Printf(_L("Testing Derived Attributes using a test Driver for Digitiser\n")); + r=User::LoadLogicalDevice(KLddFileName); + test(r==KErrNone); + + r=gLDD.Open(); + test(r==KErrNone); + + r=gLDD.registerHalHandler(); + test(r==KErrNone || r==KErrNotSupported); + + testDeviceNumber=gLDD.getRegisteredDeviceNumber(); + test(testDeviceNumber != KErrNotFound); + gLDD.initialiseHalData(); + + r=HAL::Get(testDeviceNumber,HALData::EPointer3D,halApiVal); + test(r==KErrNone); + testDriverVal=gLDD.getPointer3D(); + test(halApiVal == testDriverVal); + + r=HAL::Get(testDeviceNumber,HALData::EPointer3DMaxProximity,halApiVal); + test(r==KErrNone); + testDriverVal=gLDD.getPointer3DMaxProximity(); + test(halApiVal == testDriverVal); + + r=HAL::Get(testDeviceNumber,HALData::EPointer3DThetaSupported,halApiVal); + test(r==KErrNone); + testDriverVal=gLDD.getPointer3DThetaSupported(); + test(halApiVal == testDriverVal); + + r=HAL::Get(testDeviceNumber,HALData::EPointer3DPhiSupported,halApiVal); + test(r==KErrNone); + testDriverVal=gLDD.getPointer3DPhiSupported(); + test(halApiVal == testDriverVal); + + r=HAL::Get(testDeviceNumber,HALData::EPointer3DRotationSupported,halApiVal); + test(r==KErrNone); + testDriverVal=gLDD.getPointer3DRotationSupported(); + test(halApiVal == testDriverVal); + + r=HAL::Get(testDeviceNumber,HALData::EPointer3DPressureSupported,halApiVal); + test(r==KErrNone); + testDriverVal=gLDD.getPointer3DPressureSupported(); + test(halApiVal == testDriverVal); + + r=HAL::Get(testDeviceNumber,HALData::EPointer3DProximityStep,halApiVal); + test(r==KErrNone); + testDriverVal=gLDD.getPointer3DProximityStep(); + test(halApiVal == testDriverVal); + + r=HAL::Get(testDeviceNumber,HALData::EPointerMaxPointers,halApiVal); + test(r==KErrNone); + testDriverVal=gLDD.getPointerMaxPointers(); + test(halApiVal == testDriverVal); + + r=HAL::Get(testDeviceNumber,HALData::EPointerNumberOfPointers,halApiVal); + test(r==KErrNone); + testDriverVal=gLDD.getPointerNumberOfPointers(); + test(halApiVal == testDriverVal); + + r=HAL::Get(testDeviceNumber,HALData::EPointer3DMaxPressure,halApiVal); + test(r==KErrNone); + testDriverVal=gLDD.getPointer3DMaxPressure(); + test(halApiVal == testDriverVal); + + r=HAL::Get(testDeviceNumber,HALData::EPointer3DPressureStep,halApiVal); + test(r==KErrNone); + testDriverVal=gLDD.getPointer3DPressureStep(); + test(halApiVal == testDriverVal); + + // There are just 2 settable HAL Values. Set them using HAL APIs and get the same using + // Test Driver APIs. + r=HAL::Set(testDeviceNumber,HALData::EPointer3DMaxProximity,halPointer3DMaxProximity); + test(r==KErrNone); + testDriverVal=gLDD.getPointer3DMaxProximity(); + test(halPointer3DMaxProximity == testDriverVal); + r=HAL::Get(testDeviceNumber,HALData::EPointer3DMaxProximity,halApiVal); + test(r==KErrNone); + test(halApiVal == halPointer3DMaxProximity); + + r=HAL::Set(testDeviceNumber,HALData::EPointerNumberOfPointers,halPointerNumberOfPointers); + test(r==KErrNone); + testDriverVal=gLDD.getPointerNumberOfPointers(); + test(halPointerNumberOfPointers == testDriverVal); + r=HAL::Get(testDeviceNumber,HALData::EPointerNumberOfPointers,halApiVal); + test(r==KErrNone); + test(halApiVal == halPointerNumberOfPointers); + + // Set the Attributes values using the Driver APis and make sure that the same is + // received with HAL::Get APis + gLDD.setPointer3D(newPointer3D); + r=HAL::Get(testDeviceNumber,HALData::EPointer3D,halApiVal); + test(r==KErrNone); + test(halApiVal == newPointer3D); + + gLDD.setPointer3DMaxProximity(newPointer3DMaxProximity); + r=HAL::Get(testDeviceNumber,HALData::EPointer3DMaxProximity,halApiVal); + test(r==KErrNone); + test(halApiVal == newPointer3DMaxProximity); + + gLDD.setPointer3DThetaSupported(newPointer3DThetaSupported); + r=HAL::Get(testDeviceNumber,HALData::EPointer3DThetaSupported,halApiVal); + test(r==KErrNone); + test(halApiVal == newPointer3DThetaSupported); + + gLDD.setPointer3DPhiSupported(newPointer3DPhiSupported); + r=HAL::Get(testDeviceNumber,HALData::EPointer3DPhiSupported,halApiVal); + test(r==KErrNone); + test(halApiVal == newPointer3DPhiSupported); + + gLDD.setPointer3DRotationSupported(newPointer3DRotationSupported); + r=HAL::Get(testDeviceNumber,HALData::EPointer3DRotationSupported,halApiVal); + test(r==KErrNone); + test(halApiVal == newPointer3DRotationSupported); + + gLDD.setPointer3DPressureSupported(newPointer3DPressureSupported); + r=HAL::Get(testDeviceNumber,HALData::EPointer3DPressureSupported,halApiVal); + test(r==KErrNone); + test(halApiVal == newPointer3DPressureSupported); + + gLDD.setPointer3DProximityStep(newPointer3DProximityStep); + r=HAL::Get(testDeviceNumber,HALData::EPointer3DProximityStep,halApiVal); + test(r==KErrNone); + test(halApiVal == newPointer3DProximityStep); + + gLDD.setPointerMaxPointers(newPointerMaxPointers); + r=HAL::Get(testDeviceNumber,HALData::EPointerMaxPointers,halApiVal); + test(r==KErrNone); + test(halApiVal == newPointerMaxPointers); + + gLDD.setPointerNumberOfPointers(newPointerNumberOfPointers); + r=HAL::Get(testDeviceNumber,HALData::EPointerNumberOfPointers,halApiVal); + test(r==KErrNone); + test(halApiVal == newPointerNumberOfPointers); + + gLDD.setPointer3DMaxPressure(newPointer3DMaxPressure); + r=HAL::Get(testDeviceNumber,HALData::EPointer3DMaxPressure,halApiVal); + test(r==KErrNone); + test(halApiVal == newPointer3DMaxPressure); + + gLDD.setPointer3DPressureStep(newPointer3DPressureStep); + + r=HAL::Get(testDeviceNumber,HALData::EPointer3DPressureStep,halApiVal); + test(r==KErrNone); + test(halApiVal == newPointer3DPressureStep); + + r=gLDD.removeHalHandler(); + test(r == KErrNone); + + gLDD.Close(); + + r = User::FreeLogicalDevice(KLddFileName);; + test(r==KErrNone); + User::After(100000); + + // Finished Testing Derived attributes + test.Printf(_L("Successully Finished Testing the Derived attributes\n")); + __UHEAP_MARKEND; + } + +void DoTestNonDerivedAtributes() + { + __UHEAP_MARK; + // The following 4 HAL attributes would be tested using HAL::GET,HAL:SET APIs + // 1. EPointer3DEnterHighPressureThreshold + // 2. EPointer3DExitHighPressureThreshold + // 3. EPointer3DEnterCloseProximityThreshold + // 4. EPointer3DExitCloseProximityThreshold + //////////********TEST STEPS********//////////////////// + // Step1: Get the existing/default values using HAL:GET() and save them (for restoring it at Step4) + // Step2: Set new valuee using HAL:SET() + // Step3: Make sure that the new values are set by camparing the new valuee with the values got by HAL:GET() + // Step4: Restore the orginal values( saved at Step1) + + TInt r; + TInt halGetVal; + // Save the Original Values + TInt origPointer3DEnterHighPressureThreshold; + TInt origPointer3DExitHighPressureThreshold; + TInt origPointer3DEnterCloseProximityThreshold; + TInt origPointer3DExitCloseProximityThreshold; + + // New values to be set + TInt newPointer3DEnterHighPressureThreshold = 500; + TInt newPointer3DExitHighPressureThreshold = 300; + TInt newPointer3DEnterCloseProximityThreshold = 20; + TInt newPointer3DExitCloseProximityThreshold = 35; + + test.Printf(_L("Testing Non-Derived attributes\n")); + + // Test EPointer3DEnterHighPressureThreshold + r=HAL::Get(HALData::EPointer3DEnterHighPressureThreshold,origPointer3DEnterHighPressureThreshold); + test(r==KErrNone); + r=HAL::Set(HALData::EPointer3DEnterHighPressureThreshold,newPointer3DEnterHighPressureThreshold); + test(r==KErrNone); + r=HAL::Get(HALData::EPointer3DEnterHighPressureThreshold,halGetVal); + test(r==KErrNone); + test(halGetVal == newPointer3DEnterHighPressureThreshold); + r=HAL::Set(HALData::EPointer3DEnterHighPressureThreshold,origPointer3DEnterHighPressureThreshold); + test(r==KErrNone); + r=HAL::Get(HALData::EPointer3DEnterHighPressureThreshold,halGetVal); + test(r==KErrNone); + test(halGetVal == origPointer3DEnterHighPressureThreshold); + + // Test EPointer3DExitHighPressureThreshold + r=HAL::Get(HALData::EPointer3DExitHighPressureThreshold,origPointer3DExitHighPressureThreshold); + test(r==KErrNone); + r=HAL::Set(HALData::EPointer3DExitHighPressureThreshold,newPointer3DExitHighPressureThreshold); + test(r==KErrNone); + r=HAL::Get(HALData::EPointer3DExitHighPressureThreshold,halGetVal); + test(r==KErrNone); + test(halGetVal == newPointer3DExitHighPressureThreshold); + r=HAL::Set(HALData::EPointer3DExitHighPressureThreshold,origPointer3DExitHighPressureThreshold); + test(r==KErrNone); + r=HAL::Get(HALData::EPointer3DExitHighPressureThreshold,halGetVal); + test(r==KErrNone); + test(halGetVal == origPointer3DExitHighPressureThreshold); + + // Test EPointer3DEnterCloseProximityThreshold + r=HAL::Get(HALData::EPointer3DEnterCloseProximityThreshold,origPointer3DEnterCloseProximityThreshold); + test(r==KErrNone); + r=HAL::Set(HALData::EPointer3DEnterCloseProximityThreshold,newPointer3DEnterCloseProximityThreshold); + test(r==KErrNone); + r=HAL::Get(HALData::EPointer3DEnterCloseProximityThreshold,halGetVal); + test(r==KErrNone); + test(halGetVal == newPointer3DEnterCloseProximityThreshold); + r=HAL::Set(HALData::EPointer3DEnterCloseProximityThreshold,origPointer3DEnterCloseProximityThreshold); + test(r==KErrNone); + r=HAL::Get(HALData::EPointer3DEnterCloseProximityThreshold,halGetVal); + test(r==KErrNone); + test(halGetVal == origPointer3DEnterCloseProximityThreshold); + + // Test EPointer3DExitCloseProximityThreshold + r=HAL::Get(HALData::EPointer3DExitCloseProximityThreshold,origPointer3DExitCloseProximityThreshold); + test(r==KErrNone); + r=HAL::Set(HALData::EPointer3DExitCloseProximityThreshold,newPointer3DExitCloseProximityThreshold); + test(r==KErrNone); + r=HAL::Get(HALData::EPointer3DExitCloseProximityThreshold,halGetVal); + test(r==KErrNone); + test(halGetVal == newPointer3DExitCloseProximityThreshold); + r=HAL::Set(HALData::EPointer3DExitCloseProximityThreshold,origPointer3DExitCloseProximityThreshold); + test(r==KErrNone); + r=HAL::Get(HALData::EPointer3DExitCloseProximityThreshold,halGetVal); + test(r==KErrNone); + test(halGetVal == origPointer3DExitCloseProximityThreshold); + + // Finished Testing non-derived attributes + test.Printf(_L("Successully Finished Testing the non-derived attributes\n")); + __UHEAP_MARKEND; + } + +GLDEF_C TInt E32Main() +// +// Test Digitiser LDD +// + { + TInt machineUid=0; + // This Testing is performed only on H4,Wins and WinEmulator, so need to get the machinUID + const TInt r = HAL::Get(HAL::EMachineUid, machineUid); + if(r==KErrNone) + { + test.Start(_L("Test Start : LDDDigitiserTest")); + // Non-Derived attributes are tested using a Test Driver for Digitiser which is supported only on H4,Wins and WinEmulator + if((machineUid == HAL::EMachineUid_OmapH4) || (machineUid == HAL::EMachineUid_Win32Emulator)) + { + DoTestNonDerivedAtributes(); + } + // Derived attributes are tested using a Test Driver for Digitiser which is supported only on H4 + if(machineUid == HAL::EMachineUid_OmapH4) + { + DoTestOnUnregisteredDevice(); + DoTestDerivedeAtributes(); + } + } + test.End(); + test.Close(); + return(KErrNone); + }