// Copyright (c) 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:
// Test suite to check whether the device has good enough entropy sources or not.
// More the no. of sources, high the quality of the random numbers (least predictable).
// 
//

/**
 @file
 @internalTechnology
*/

#define __E32TEST_EXTENSION__
#include <e32test.h>
#include <hal.h>
#include <e32math.h>
#include "d_entropysources.h"

//---------------------------------------------------------------------------------------------------------------------
//! @SYMTestCaseID				KBASE-entropysources-2703
//! @SYMTestType				UT
//! @SYMTestCaseDesc			Verifies that entropy is contributed to the Secure RNG
//! @SYMPREQ					PREQ211
//! @SYMTestPriority			High
//! @SYMTestActions				
//! 	1. 	TestReseed: tests that the interval between RNG reseeds is less than KMaxReseedTime, unless the platform is 
//!         known not to have a viable entropy source.
//! 		
//! 
//! @SYMTestExpectedResults
//! 	1.	Properties checked:
//! 		1) checks that there is a valid entropy source contrbuting entropy data.
//!         2) checks that the entropy collection framework is functioning correctly..
//! 	
//---------------------------------------------------------------------------------------------------------------------

// In a worst case scenario, we expect the reseed to happen within ten minutes.
// This is approximately 1/10 of the actual reseed intervel time (97.8 rounded to => 98).
// ((2^24 (reseed intervel) * 350 (micro seconds per request)) / 1000000) / 60 => 97.8 minutes.
//
const TTimeIntervalMicroSeconds32 KMaxReseedTime = 10 * 60 * 1000000;

REntropySources Ldd;

LOCAL_D RTest test(_L("T_ENTROPYSOURCES"));

LOCAL_C void TestReseed()
    {    
    test.Next(_L("Loading test driver"));
    TInt r = User::LoadLogicalDevice(KEntropySourcesName);
    test(r==KErrNone || r==KErrAlreadyExists);
    
    test.Next(_L("Opening the logical channel"));
    test_KErrNone(Ldd.Open());
    
	RTimer timer;
	test_KErrNone(timer.CreateLocal());

	test.Next(_L("Testing reseed interval"));
	// Wait for two reseeds, so we can prove the interval between them is ok
	for (TInt i=0; i<2; ++i)
		{
		// Request notification of the next reseed, with a timeout
		test.Next(_L("Requesting reseed notification"));
		TRequestStatus reseed, timeout;
		Ldd.ReseedTest(reseed);
		timer.After(timeout, KMaxReseedTime);

		// Prod the RNG to make sure it's not idle, then wait for an event
		test.Next(_L("Prod RNG and wait"));
		Math::Random();
		User::WaitForRequest(reseed, timeout);

		// Check we didn't time out and cancel the timer
		test_Equal(KRequestPending, timeout.Int());
		timer.Cancel();
		User::WaitForRequest(timeout);
		test_Equal(KErrCancel, timeout.Int());
		test_KErrNone(reseed.Int());
		}
	
	Ldd.Close();

	User::FreeLogicalDevice(KEntropySourcesName);
    }

LOCAL_C TBool HardwareRNGPresent()
    {
    TInt muid = 0;
    const TInt r = HAL::Get(HAL::EMachineUid, muid);
    if (r != KErrNone) return EFalse;;
    return ((muid != HAL::EMachineUid_X86PC) &&
            (muid != HAL::EMachineUid_NE1_TB) &&
            (muid != HAL::EMachineUid_OmapH6) &&
            (muid != HAL::EMachineUid_OmapZoom) &&
            (muid != HAL::EMachineUid_Win32Emulator));
    }

GLDEF_C TInt E32Main()
	{
	test.Title();
	test.Start(_L("Test periodic entropy source"));

	if(HardwareRNGPresent())	
	    {
	    __UHEAP_MARK;
        
		TestReseed();

        __UHEAP_MARKEND;	    
	    }
	else
	    {
	    test.Printf(_L("Test skipped, platform is known not to have a periodic entropy source\n"));
	    }
	test.End();
	test.Close();
	
	return 0;
	}