// 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 <e32test.h>
#include <e32hal.h>
#include "d_lddDigitisertest.h"
#include <hal.h>
_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;
}
void DoTestTEvntTypes()
{
TInt r;
TRawEvent::TType firstEvent=TRawEvent::ENone;
TRawEvent::TType lastEvent=TRawEvent::ERestartSystem;
for(int i=firstEvent;i<=lastEvent;++i)
{
gLDD.setTEvntType(i);
r=gLDD.getTEvntType();
test(r == i);
}
}
void DoTestTEvntDNum()
{
TInt r;
TInt aDvcNum1=2;
TInt aDvcNum2=100;
gLDD.setTEvntDNum(aDvcNum1);
r=gLDD.getTEvntDNum();
test(r == aDvcNum1);
gLDD.setTEvntDNum(aDvcNum2);
r=gLDD.getTEvntDNum();
test(r == aDvcNum2);
}
void DoTestTEvntScanCode()
{
TInt r;
TInt aScanCode1=0;
TInt aScanCode2=235;
gLDD.setTEvntScanCode(TRawEvent::EPointer3DInRange, aScanCode1);
r=gLDD.getTEvntScanCode();
test(r == aScanCode1);
gLDD.setTEvntScanCode(TRawEvent::EPointer3DRotation, aScanCode2);
r=gLDD.getTEvntScanCode();
test(r == aScanCode2);
}
void DoTestTEvnTilt()
{
TInt aPhi1 =0, aTheta1=3;
TInt aPhi2 =20, aTheta2=45;
TInt r;
TUsrEventBuf eventBuf;
r=gLDD.setTEvntTilt(TRawEvent::EPointerMove,aPhi1,aTheta1);
test(r==KErrNone);
r=gLDD.getTEvntTilt(eventBuf);
test(r==KErrNone);
test((eventBuf().iPhi == aPhi1) && (eventBuf().iTheta == aTheta1));
r=gLDD.setTEvntTilt(TRawEvent::EPointer3DInRange,aPhi2,aTheta2);
test(r==KErrNone);
r=gLDD.getTEvntTilt(eventBuf);
test(r==KErrNone);
test((eventBuf().iPhi == aPhi2) && (eventBuf().iTheta == aTheta2));
}
void DoTestTEvntRotation()
{
TInt r;
TInt aRotation1 =12, aRotation2=323;
r=gLDD.setTEvntRotation(TRawEvent::EPointerMove,aRotation1);
test(r==KErrNone);
r=gLDD.getTEvntRotation();
test(r == aRotation1);
r=gLDD.setTEvntRotation(TRawEvent::EPointerMove,aRotation2);
test(r==KErrNone);
r=gLDD.getTEvntRotation();
test(r == aRotation2);
}
void DoTestTEvntPtr()
{
TInt r;
TUint8 aPointerNumber1=123;
TUint8 aPointerNumber2=2;
TUint8 aPointerNumber3=3;
TUint8 aPointerNumber4=125;
TPoint3D tPoint3D1(-23 ,-85 ,-93);
TPoint3D tPoint3D2(-23 ,0 ,100);
TUsrEventBuf eventBuf;
r=gLDD.setTEvnt3DnPntr(TRawEvent::EPointerMove,tPoint3D1.iX,tPoint3D1.iY,tPoint3D1.iZ,aPointerNumber1);
test(r==KErrNone);
r=gLDD.getTEvntPntr();
test(r == aPointerNumber1);
r=gLDD.getTEventPos3D(eventBuf);
test(r==KErrNone);
test((eventBuf().iX == tPoint3D1.iX) && (eventBuf().iY == tPoint3D1.iY) && (eventBuf().iZ == tPoint3D1.iZ) );
gLDD.setTEvntPntr(aPointerNumber2);
r=gLDD.getTEvntPntr();
test(r == aPointerNumber2);
r=gLDD.setTEvnt3DnPntr(TRawEvent::EPointerMove,tPoint3D2.iX,tPoint3D2.iY,tPoint3D2.iZ,aPointerNumber3);
test(r==KErrNone);
r=gLDD.getTEvntPntr();
test(r == aPointerNumber3);
r=gLDD.getTEventPos3D(eventBuf);
test(r==KErrNone);
test((eventBuf().iX == tPoint3D2.iX) && (eventBuf().iY == tPoint3D2.iY) && (eventBuf().iZ == tPoint3D2.iZ) );
gLDD.setTEvntPntr(aPointerNumber4);
r=gLDD.getTEvntPntr();
test(r == aPointerNumber4);
}
void DoTestTEvntTicksNTips()
{
TInt r;
TBool aTip=true;
gLDD.setTEvntTip(aTip);
r=gLDD.TEvntTicksIsTip();
test(r == aTip);
aTip=false;
gLDD.setTEvntTip(aTip);
r=gLDD.TEvntTicksIsTip();
test(r == aTip);
r=gLDD.getTEvntTicks();
test(r > 0 );
}
void DoTestTEvntPOS2D()
{
TInt r;
TPoint tPoint1(0,0);
TPoint tPoint2(323232,45454);
TPoint tPoint3(-85 ,-93);
TPoint tPoint4 (0 ,100);
TUsrEventBuf eventBuf;
r=gLDD.setTEvntPos(TRawEvent::EPointerMove,tPoint1.iX,tPoint1.iY);
test(r==KErrNone);
r=gLDD.getTEvntPos(eventBuf);
test(r==KErrNone);
test((eventBuf().iX == tPoint1.iX) && (eventBuf().iY == tPoint1.iY) );
r=gLDD.setTEvntPos(TRawEvent::EPointerMove,tPoint2.iX,tPoint2.iY);
test(r==KErrNone);
r=gLDD.getTEvntPos(eventBuf);
test(r==KErrNone);
test((eventBuf().iX == tPoint2.iX) && (eventBuf().iY == tPoint2.iY) );
r=gLDD.setTEvntPos(TRawEvent::EPointerMove,tPoint3.iX,tPoint3.iY);
test(r==KErrNone);
r=gLDD.getTEvntPos(eventBuf);
test(r==KErrNone);
test((eventBuf().iX == tPoint3.iX) && (eventBuf().iY == tPoint3.iY) );
r=gLDD.setTEvntPos(TRawEvent::EPointerMove,tPoint4.iX,tPoint4.iY);
test(r==KErrNone);
r=gLDD.getTEvntPos(eventBuf);
test(r==KErrNone);
test((eventBuf().iX == tPoint4.iX) && (eventBuf().iY == tPoint4.iY) );
}
void DoTestTEvntRepeat()
{
TInt r;
TInt aType=TRawEvent::EPointerMove;
TInt aScanCode=20;
TInt aRepeats1=1;
TInt aRepeats2=13430;
TInt aRepeats3=0;
r=gLDD.setTEvntRepeat(aType,aScanCode,aRepeats1);
test(r==KErrNone);
r=gLDD.getTEvntRepeat();
test( r== aRepeats1);
r=gLDD.setTEvntRepeat(aType,aScanCode,aRepeats2);
test(r==KErrNone);
r=gLDD.getTEvntRepeat();
test( r== aRepeats2);
r=gLDD.setTEvntRepeat(aType,aScanCode,aRepeats3);
test(r==KErrNone);
r=gLDD.getTEvntRepeat();
test( r== aRepeats3);
}
void DoTestTEvntPos3D()
{
TPoint3D tPoint3D1(0,0,0);
TPoint3D tPoint3D2(23232,323232,45454);
TPoint3D tPoint3D3(-23 ,-85 ,-93);
TPoint3D tPoint3D4(-23 ,0 ,100);
TUsrEventBuf eventBuf;
TInt r;
r=gLDD.setTEvntPos3D(TRawEvent::EPointerMove,tPoint3D1.iX,tPoint3D1.iY,tPoint3D1.iZ);
test(r==KErrNone);
r=gLDD.getTEventPos3D(eventBuf);
test(r==KErrNone);
test((eventBuf().iX == tPoint3D1.iX) && (eventBuf().iY == tPoint3D1.iY) && (eventBuf().iZ == tPoint3D1.iZ) );
r=gLDD.setTEvntPos3D(TRawEvent::EPointer3DInRange,tPoint3D2.iX,tPoint3D2.iY,tPoint3D2.iZ);
test(r==KErrNone);
r=gLDD.getTEventPos3D(eventBuf);
test(r==KErrNone);
test((eventBuf().iX == tPoint3D2.iX) && (eventBuf().iY == tPoint3D2.iY) && (eventBuf().iZ == tPoint3D2.iZ) );
r=gLDD.setTEvntPos3D(TRawEvent::EPointer3DRotation,tPoint3D3.iX,tPoint3D3.iY,tPoint3D3.iZ);
test(r==KErrNone);
r=gLDD.getTEventPos3D(eventBuf);
test(r==KErrNone);
test((eventBuf().iX == tPoint3D3.iX) && (eventBuf().iY == tPoint3D3.iY) && (eventBuf().iZ == tPoint3D3.iZ) );
r=gLDD.setTEvntPos3D(TRawEvent::EPointer3DTiltAndMove,tPoint3D4.iX,tPoint3D4.iY,tPoint3D4.iZ);
test(r==KErrNone);
r=gLDD.getTEventPos3D(eventBuf);
test(r==KErrNone);
test((eventBuf().iX == tPoint3D4.iX) && (eventBuf().iY == tPoint3D4.iY) && (eventBuf().iZ == tPoint3D4.iZ) );
}
void DoTestTEvntPos3DAll()
{
TInt r;
TPoint3D tPoint3D1(0,322,45454);
TPoint3D tPoint3D2(-23 ,0 ,-93);
TInt aPhi1 =0, aTheta1=3, alpha1=10;
TInt aPhi2 =20, aTheta2=45,alpha2=126;
TRawEvent::TType event1 =TRawEvent::EPointerMove;
TRawEvent::TType event2= TRawEvent::EPointer3DRotation;
TUsrEventBuf eventBuf;
r=gLDD.setTEvntAll(event1,tPoint3D1.iX,tPoint3D1.iY,tPoint3D1.iZ,aPhi1,aTheta1,alpha1);
test(r==KErrNone);
r=gLDD.getTEvntType();
test(r == event1);
r=gLDD.getTEventPos3D(eventBuf);
test(r==KErrNone);
test((eventBuf().iX == tPoint3D1.iX) && (eventBuf().iY == tPoint3D1.iY) && (eventBuf().iZ == tPoint3D1.iZ) );
r=gLDD.getTEvntRotation();
test(r == alpha1);
r=gLDD.getTEvntTilt(eventBuf);
test(r==KErrNone);
test((eventBuf().iPhi == aPhi1) && (eventBuf().iTheta == aTheta1));
r=gLDD.setTEvntAll(event2,tPoint3D2.iX,tPoint3D2.iY,tPoint3D2.iZ,aPhi2,aTheta2,alpha2);
test(r==KErrNone);
r=gLDD.getTEvntType();
test(r == event2);
r=gLDD.getTEventPos3D(eventBuf);
test(r==KErrNone);
test((eventBuf().iX == tPoint3D2.iX) && (eventBuf().iY == tPoint3D2.iY) && (eventBuf().iZ == tPoint3D2.iZ) );
r=gLDD.getTEvntRotation();
test(r == alpha2);
r=gLDD.getTEvntTilt(eventBuf);
test(r==KErrNone);
test((eventBuf().iPhi == aPhi2) && (eventBuf().iTheta == aTheta2));
}
void DoTestKernelTrawEvents()
{
__UHEAP_MARK;
TInt r;
test.Printf(_L("Testing KernelSide TrawEvents \n"));
r=User::LoadLogicalDevice(KLddFileName);
test(r==KErrNone);
r=gLDD.Open();
test(r==KErrNone);
//Test Kernel Side TRawevents
DoTestTEvntTypes();
DoTestTEvntDNum();
DoTestTEvntScanCode();
DoTestTEvnTilt();
DoTestTEvntRotation();
DoTestTEvntPtr();
DoTestTEvntTicksNTips();
DoTestTEvntPOS2D();
DoTestTEvntRepeat();
DoTestTEvntPos3D();
DoTestTEvntPos3DAll();
gLDD.Close();
r = User::FreeLogicalDevice(KLddFileName);;
test(r==KErrNone);
User::After(100000);
// Finished Testing Derived attributes
test.Printf(_L("Successully Finished Testing KernelSide TrawEvents \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();
DoTestKernelTrawEvents();
}
}
test.End();
test.Close();
return(KErrNone);
}