diff -r 9aca3be14c27 -r 75252ea6123b kerneltest/e32test/system/t_khal.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/kerneltest/e32test/system/t_khal.cpp Mon Jul 26 10:52:56 2010 +0100 @@ -0,0 +1,278 @@ +// Copyright (c) 2010 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\system\t_khal.cpp +// Overview: +// Test class Kern HAL APIs +// API Information: +// Kern::AddHalEntry(), Kern::RemoveHalEntry(), Kern::FindHalEntry() +// Details: +// - Adds a new HAL handler for EHalGroupPlatformSpecific2 +// - Tries to add handler for an existing group +// - Calls the installed handler +// - Tests Find API to find the installed handler +// - Removes the handler and tries to remove some fixed HAL group +// - Tries to find removed handler +// - Tries to call removed handler +// Platforms/Drives/Compatibility: +// All. +// Assumptions/Requirement/Pre-requisites: +// Failures and causes: +// Base Port information: +// +// + +#define __E32TEST_EXTENSION__ + +#include +#include +#include +#include +#include "d_khal.h" +#include + +RLddKHalTest gLdd; +GLDEF_D RTest test(_L("T_KHAL - class Kern HAL API test")); + + +TBool gEntryForDevice0Registered; // indicator whether the device0 got registered +TBool gEntryForDeviceXRegistered; // indicator whether the deviceX got registered +TInt gTestDeviceNumber; // device number that was registered + + +void TestAddHalHandler() + { + TInt r; + + // Try to register PlatformSpecific2 handler for Device 0 + test.Next(_L("Register new HAL handler - device 0")); + r=gLdd.AddHalEntryDevice0(); + // we dont want to test() the value, since it might actually not be able to register the + // default device, if one already exists in the system + if (r==KErrNone) + { + gEntryForDevice0Registered=ETrue; + } + else + { + gEntryForDevice0Registered=EFalse; + test.Printf(_L("Couldn't register handler for device 0 (r=%d). Some test cases will not be executed"),r); + } + // lets try again for device0 if succeeded for the first time, should return error + if (gEntryForDevice0Registered) + { + test.Next(_L("Try to register new HAL handler again for Device0")); + test_Equal(KErrInUse,gLdd.AddHalEntryDevice0()); + } + + // Try to register PlatformSpecific2 handler for Device X. Trying for multiple devices, so + // it's highly unlikely that baseport has added this many devices for this group. + test.Next(_L("Register new HAL handler - device X")); + + r=gLdd.AddHalEntryDeviceX(); + if (r==KErrNone) + { + gEntryForDeviceXRegistered = ETrue; + } + else + { + gEntryForDeviceXRegistered = EFalse; + test.Printf(_L("FAILED to register any device for EHalGroupPlatformSpecific2 (r=%d). Some test cases will not be executed"),r); + } + + test_Value(r, (r==KErrNone || r==KErrInUse)); // this should not fail, but if it does, print indication + + if (gEntryForDeviceXRegistered) + { + gTestDeviceNumber=gLdd.GetRegisteredDeviceNumber(); + test(gTestDeviceNumber != KErrNotFound); + } + + test.Next(_L("Try to register new HAL handler for fixed group (EHalGroupKernel) - should not be possible")); + test_Equal(KErrArgument,gLdd.AddHalEntryForExistingFixed()); + } + +void TestCallHalHandler() + { + test.Next(_L("Call HAL handler function - device 0")); + if (gEntryForDevice0Registered) + { + test_KErrNone(UserSvr::HalFunction(EHalGroupPlatformSpecific2,RLddKHalTest::ETestHalFunc,0,0)); + } + else + { + test.Printf(_L("Didn't try to call handler for device 0, since it wasn't registered in the beginning")); + } + + test.Next(_L("Call HAL handler function - device X")); + if (gEntryForDeviceXRegistered) + { + test_KErrNone(UserSvr::HalFunction(EHalGroupPlatformSpecific2,RLddKHalTest::ETestHalFunc,0,0,gTestDeviceNumber)); + } + else + { + test.Printf(_L("Didn't try to call handler for device x, since it wasn't registered in the beginning")); + } + } + +void TestCallRemovedHalHandler() + { + TInt r; + + test.Next(_L("Call removed HAL handler function - device 0")); + if (gEntryForDevice0Registered) + { + r=UserSvr::HalFunction(EHalGroupPlatformSpecific2,RLddKHalTest::ETestHalFunc,0,0); + test_Compare(r, !=, KErrNone); + } + else + { + test.Printf(_L("Didn't try to call removed handler for device 0, since it wasn't registered in the beginning")); + } + + test.Next(_L("Call removed HAL handler function - device X")); + if (gEntryForDeviceXRegistered) + { + r=UserSvr::HalFunction(EHalGroupPlatformSpecific2,RLddKHalTest::ETestHalFunc,0,0,gTestDeviceNumber); + test_Compare(r, !=, KErrNone); + } + else + { + test.Printf(_L("Didn't try to call removed handler for device x, since it wasn't registered in the beginning")); + } + } + +void TestFindHalHandler() + { + test.Next(_L("Try with one parameter find (device 0) for own handler")); + if (gEntryForDevice0Registered) + { + test_KErrNone(gLdd.FindHalEntryDevice0()); + } + else + { + test.Printf(_L("Didn't try to find handler for device 0, since it wasn't registered in the beginning")); + } + + test.Next(_L("Try with one parameter find (device 0) for an existing group")); + test_KErrNone(gLdd.FindHalEntryDevice0Other()); // should find because trying to get EHalGroupKernel, which must exist + + test.Next(_L("Try with two parameter find (device x)")); + if (gEntryForDeviceXRegistered) + { + test_KErrNone(gLdd.FindHalEntryDeviceX()); // should find because handler for device x has been registered + } + else + { + test.Printf(_L("Didn't try to find handler for device X, since it wasn't registered in the beginning")); + } + } + +void TestRemoveHalHandler() + { + test.Next(_L("Remove HAL handler - device 0")); + if (gEntryForDevice0Registered) + { + test_KErrNone(gLdd.RemoveHalEntryDevice0()); + } + else + { + test.Printf(_L("Didn't try to remove handler for device 0, since it wasn't registered in the beginning")); + } + + test.Next(_L("Remove HAL handler - device X")); + if (gEntryForDeviceXRegistered) + { + test_KErrNone(gLdd.RemoveHalEntryDeviceX()); + } + else + { + test.Printf(_L("Didn't try to remove handler for device x, since it wasn't registered in the beginning")); + } + + test.Next(_L("Remove fixed HAL handler (EHalGroupKernel) - should not be possible")); + test_Equal(KErrArgument,gLdd.RemoveHalEntryExistingFixed()); + } + +void TestFindRemovedHalHandler() + { + test.Next(_L("Try with one parameter find (device 0) for removed handler")); + if (gEntryForDevice0Registered) + { + test_Equal(KErrNotFound,gLdd.FindHalEntryDevice0()); + } + else + { + test.Printf(_L("didn't try to find removed HAL handler for device 0 since it wasn't registered in the beginning")); + } + + test.Next(_L("Try with two parameter find (device x) for removed handler")); + if (gEntryForDeviceXRegistered) + { + test_Equal(KErrNotFound,gLdd.FindHalEntryDeviceX()); + } + else + { + test.Printf(_L("didn't try to find removed HAL handler for device X since it wasn't registered in the beginning")); + } + } + +void LoadDeviceDriver() + { + test_KErrNone(User::LoadLogicalDevice(KLddName)); + test_KErrNone(gLdd.Open()); + } + +void UnLoadDeviceDriver() + { + gLdd.Close(); + test_KErrNone(User::FreeLogicalDevice(KLddName)); + } + + +GLDEF_C TInt E32Main() +// +// Test Kern HAL API +// + { + test.Title(); + + test.Start(_L("Test class Kern HAL API functions")); + // load the driver + LoadDeviceDriver(); + + // add handlers for default device (0) and Device X + TestAddHalHandler(); + + // call handlers that were managed to register + TestCallHalHandler(); + + // test find APIs + TestFindHalHandler(); + + // test removal of HAL handlers + TestRemoveHalHandler(); + + // test find APIs for removed handlers + TestFindRemovedHalHandler(); + + // try to call removed handlers + TestCallRemovedHalHandler(); + + // unload the driver + UnLoadDeviceDriver(); + + test.End(); + test.Close(); + return(KErrNone); + }