// 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 <e32test.h>
#include <e32hal.h>
#include <u32hal.h>
#include <e32svr.h>
#include "d_khal.h"
#include <hal.h>

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);
    }