// Copyright (c) 2006-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:

// f32test\plugins\version_2beta\encrypt\t_plugin_v2beta.cpp

//

//

#include <f32file.h>

#include <e32test.h>

#include <e32svr.h>

#include <f32dbg.h>

#include "f32_test_utils.h"

#include "t_server.h"

#include "encrypt.h"

#include "hex.h"

GLREF_C void TestIfEqual( TInt aValue, TInt aExpected, TInt aLine, char aFileName[]);

#define TEST_FOR_ERROR( r )	{ TInt _r = (r); if (_r < 0) HandleError(_r, __LINE__); }

#define TEST_FOR_VALUE( r, expected ) TestIfEqual( r, expected, __LINE__, __FILE__)

LOCAL_C TBool gFileSystemExtensionLoaded = EFalse;

LOCAL_C void HandleError(TInt aError, TInt aLine)

	{

	test.Printf(_L("Error %d\n"), aError);

	test.operator()(EFalse, aLine);

	}

_LIT(KLitTestFileName,"encryptedfile.txt");

_LIT8( KSampleText, "line 0 abcdefghijklmnopqrstuvwxyz\n"

					"line 1 abcdefghijklmnopqrstuvwxyz\n"

					"line 2 abcdefghijklmnopqrstuvwxyz\n"

					"line 3 abcdefghijklmnopqrstuvwxyz\n"

					"line 4 abcdefghijklmnopqrstuvwxyz\n"

					"line 5 abcdefghijklmnopqrstuvwxyz\n"

					"line 6 abcdefghijklmnopqrstuvwxyz\n"

					"line 7 abcdefghijklmnopqrstuvwxyz\n"

					"line 8 abcdefghijklmnopqrstuvwxyz\n"

					"line 9 abcdefghijklmnopqrstuvwxyz\n");

_LIT( KValueTestFailMsg, "ERROR Got %d expected %d" );

GLDEF_C void TestIfEqual( TInt aValue, TInt aExpected, TInt aLine, char aFileName[])

	{

	if( aExpected != aValue )

		{

		TText filenameU[512];

		TUint i = 0;

		for (; (i < sizeof(filenameU)) && (aFileName[i] != (char)0); i++)

			{

			filenameU[i]=aFileName[i];

			}

		filenameU[i]=0;

		test.Printf( KValueTestFailMsg, aValue, aExpected );

		test.operator()( EFalse, aLine, &filenameU[0]);

		}

	}

GLDEF_D RTest test(_L("t_plugin_v2beta"));

void TestFileAccessBeforeEncryptionPlugin()

	{

	//Check that we can read all the files we want before the

	//encryption plugin is loaded.

	test.Next(_L("Test opening files before encryption plugin is installed"));

	RFile file;

	TInt r = file.Replace(TheFs, KLitTestFileName, EFileShareAny);

	TEST_FOR_ERROR(r);

	TBuf8<512> binBuffer;

	binBuffer.Copy(KSampleText);

	Encrypt(binBuffer);

	TBuf8<512*2> hexBuffer;

	Hex(binBuffer, hexBuffer);

	r = file.Write(hexBuffer);

	TEST_FOR_ERROR(r);

	r = file.Flush();

	TEST_FOR_ERROR(r);

	file.Close();

	}

void TestLoadingOfEncryptionPlugin()

	{

	test.Next(_L("Test the loading of the encryption plugin"));

	// Try loading the encryption plugin.

	TInt r = TheFs.AddPlugin(_L("t_enchook"));

	TEST_FOR_ERROR(r);

	// Try loading the encryption plugin again.

	r = TheFs.AddPlugin(_L("t_enchook"));

	TEST_FOR_VALUE(r, KErrAlreadyExists);

	// Try mounting the plugin

	r = TheFs.MountPlugin(_L("EncHook"));

	TEST_FOR_ERROR(r);

	//Test the name functions

	TFullName encName;

	r = TheFs.PluginName(encName,0,1);

	test.Printf(_L("Encryption plugin name is: %S\n"), &encName);

	}

void TestUnloadingOfEncryptionPlugin()

	{

	test.Next(_L("Test unloading the encryption plugin"));

	//Unload the encryption plugin

	//Wait for it to empty it's input queue.

	User::After(3000000);

	TInt r = TheFs.DismountPlugin(_L("EncHook"));

	TEST_FOR_ERROR(r);

	r = TheFs.DismountPlugin(_L("EncHook"));

	TEST_FOR_VALUE(r, KErrNotFound);

	r = TheFs.RemovePlugin(_L("EncHook"));

	TEST_FOR_ERROR(r);

	r = TheFs.RemovePlugin(_L("EncHook"));

	TEST_FOR_VALUE(r, KErrNotFound);

	}

void TestFileAccessDuringEncryptionPluginL()

	{

	RFile file;

	TBuf8<512> buf;

	TInt len = KSampleText().Length();

	TPtr8 buffer((TUint8*) buf.Ptr(), len, len);

	test.Next(_L("Test opening & reading files with the encryption plugin installed"));

	TInt r = file.Open(TheFs, KLitTestFileName, EFileShareAny);

	TEST_FOR_ERROR(r);

	buffer.SetLength(KSampleText().Length());

	r = file.Read(buffer);

	TInt driveNum = CurrentDrive();

	TFSName name;

	TInt err = TheFs.FileSystemName(name, driveNum);

	if (err != KErrNone)

		{

		test.Printf(_L("Drive %C: is not ready!"), 'A'+driveNum);

		test(EFalse);

		}

	else

		if ((gFileSystemExtensionLoaded || name.CompareF(_L("Win32"))==0)&& r == KErrNotSupported)

			{

			test.Printf(_L("File system extension does not support local buffers\n"));

			file.Close();

			return;

			}

	TEST_FOR_ERROR(r);

	r = buffer.Compare(KSampleText);

	TEST_FOR_VALUE(r, KErrNone);

	// read again - this should be read from cache

	TInt startPos = 0;

	file.Seek(ESeekStart, startPos);

	r = file.Read(buffer);

	TEST_FOR_ERROR(r);

	r = buffer.Compare(KSampleText);

	TEST_FOR_VALUE(r, KErrNone);

	file.Close();

	}

void TestFileAccessAfterEncryptionPlugin()

	{

	test.Next(_L("Test opening files after encryption plugin is uninstalled"));

	}

void TestFormatDriveIntercept()

    {

    test.Next(_L("Test intercepting of formatting of the drive"));

    RFormat format;

    TInt tracksRemaining;

    gSessionPath = _L("?:\\F32-TST\\");

    gSessionPath[0] = (TText) gDriveToTest;

    TInt r = format.Open(TheFs, gSessionPath, EQuickFormat, tracksRemaining);

    TEST_FOR_VALUE(r, KErrNone);

    // Don't format the whole drive to save time since

    // it is plugin intercept which is being tested and not

    // the format operation itself

    r = format.Next(tracksRemaining);

    TEST_FOR_VALUE(r, KErrNone);

    format.Close();

    }

void TestFormatDriveAfterFormatPlugin()

    {

    test.Next(_L("Test formatting of the drive after plugin unloaded"));

    RFormat format;

    TInt tracksRemaining;

    gSessionPath = _L("?:\\F32-TST\\");

    gSessionPath[0] = (TText) gDriveToTest;

    TInt r = format.Open(TheFs, gSessionPath, EQuickFormat, tracksRemaining);

    TEST_FOR_VALUE(r, KErrNone);

    while(tracksRemaining)

        {

        r = format.Next(tracksRemaining);

        TEST_FOR_VALUE(r, KErrNone);

        }

    format.Close();

    }

void TestLoadingOfHexPlugin()

	{

	test.Next(_L("Test the loading of the hex plugin"));

	// Try loading the hex plugin.

	TInt r = TheFs.AddPlugin(_L("t_hexhook"));

	TEST_FOR_ERROR(r);

	// Try loading the hex plugin again.

	r = TheFs.AddPlugin(_L("t_hexhook"));

	TEST_FOR_VALUE(r, KErrAlreadyExists);

	// Try mounting the plugin

	r = TheFs.MountPlugin(_L("HexHook"));

	TEST_FOR_ERROR(r);

	//Test the name functions

	TFullName hexName;

	r = TheFs.PluginName(hexName,0,2);

	test.Printf(_L("Hex plugin name is: %S\n"), &hexName);

	}

void TestUnloadingOfHexPlugin()

	{

	test.Next(_L("Test unloading the hex plugin"));

	//Unload the hex plugin

	//Wait for it to empty it's input queue.

	User::After(3000000);

	TInt r = TheFs.DismountPlugin(_L("HexHook"));

	TEST_FOR_ERROR(r);

	r = TheFs.DismountPlugin(_L("HexHook"));

	TEST_FOR_VALUE(r, KErrNotFound);

	r = TheFs.RemovePlugin(_L("HexHook"));

	TEST_FOR_ERROR(r);

	r = TheFs.RemovePlugin(_L("HexHook"));

	TEST_FOR_VALUE(r, KErrNotFound);

	}

void TestLoadingOfTracePlugin()

	{

	test.Next(_L("Test the loading of the trace plugin"));

	// Try loading the trace plugin.

	TInt r = TheFs.AddPlugin(_L("t_tracehook"));

	TEST_FOR_ERROR(r);

	// Try loading the trace plugin again.

	r = TheFs.AddPlugin(_L("t_tracehook"));

	TEST_FOR_VALUE(r, KErrAlreadyExists);

	// Try mounting the plugin

	r = TheFs.MountPlugin(_L("TraceHook"));

	TEST_FOR_ERROR(r);

	//Test the name functions

	TFullName traceName;

	r = TheFs.PluginName(traceName,0,0);

	test.Printf(_L("Trace plugin name is: %S\n"), &traceName);

	}

void TestUnloadingOfTracePlugin()

	{

	test.Next(_L("Test unloading the trace plugin"));

	//Unload the trace plugin

	//Wait for it to empty it's input queue.

	User::After(3000000);

	TInt r = TheFs.DismountPlugin(_L("TraceHook"));

	TEST_FOR_ERROR(r);

	r = TheFs.DismountPlugin(_L("TraceHook"));

	TEST_FOR_VALUE(r, KErrNotFound);

	r = TheFs.RemovePlugin(_L("TraceHook"));

	TEST_FOR_ERROR(r);

	r = TheFs.RemovePlugin(_L("TraceHook"));

	TEST_FOR_VALUE(r, KErrNotFound);

	}

void TestLoadingOfFormatPlugin()

    {

    test.Next(_L("Test the loading of the format plugin"));

    // Try loading the format plugin.

    TInt r = TheFs.AddPlugin(_L("t_formathook"));

    TEST_FOR_ERROR(r);

    // Try loading the format plugin again.

    r = TheFs.AddPlugin(_L("t_formathook"));

    TEST_FOR_VALUE(r, KErrAlreadyExists);

    // Try mounting the plugin

    r = TheFs.MountPlugin(_L("FormatHook"));

    TEST_FOR_ERROR(r);

    //Test the name functions

    TFullName formatName;

    r = TheFs.PluginName(formatName,0,0);

    test.Printf(_L("Format plugin name is: %S\n"), &formatName);

    }

void TestUnloadingOfFormatPlugin()

    {

    test.Next(_L("Test unloading the format plugin"));

    //Unload the format plugin

    //Wait for it to empty it's input queue.

    User::After(3000000);

    TInt r = TheFs.DismountPlugin(_L("FormatHook"));

    TEST_FOR_ERROR(r);

    r = TheFs.DismountPlugin(_L("FormatHook"));

    TEST_FOR_VALUE(r, KErrNotFound);

    r = TheFs.RemovePlugin(_L("FormatHook"));

    TEST_FOR_ERROR(r);

    r = TheFs.RemovePlugin(_L("FormatHook"));

    TEST_FOR_VALUE(r, KErrNotFound);

    }

void DeleteFiles()

	{

	test.Next(_L("Cleanup files"));

	TInt r = TheFs.Delete(KLitTestFileName);

	TEST_FOR_ERROR(r);

	}

GLDEF_C void CallTestsL()

	{

	TInt theDrive;

	TInt r = TheFs.CharToDrive(gDriveToTest,theDrive);

	test(r == KErrNone);

	TVolumeInfo volInfo;

	r = TheFs.Volume(volInfo, theDrive);

	test (r == KErrNone);

	if (volInfo.iDrive.iType == EMediaRam)

		{

#if defined(__WINS__)

		if(gDriveToTest != 'C')

			{

#endif

			test.Printf(_L("Plugin not supported on RAM drive\n"));

			return;

#if defined(__WINS__)

			}

#endif

		}

	TFullName extName;

	r = TheFs.ExtensionName(extName,theDrive, 0);

	if (r == KErrNone)

		{

		test.Printf(_L("File system extension is present (%S)\n"), &extName);

		gFileSystemExtensionLoaded = ETrue;

		}

	else

		{

		test.Printf(_L("File system extension not present.\n"));

		}

	TestFileAccessBeforeEncryptionPlugin();

	TestLoadingOfTracePlugin();

	TestLoadingOfEncryptionPlugin();

	TestLoadingOfHexPlugin();

	TestFileAccessDuringEncryptionPluginL();

	TestUnloadingOfHexPlugin();

	TestUnloadingOfEncryptionPlugin();

	TestUnloadingOfTracePlugin();

	TestFileAccessAfterEncryptionPlugin();

	DeleteFiles();

	// run T_FILE with trace plugin installed

#if defined(__WINS__)	// only in WINS to save time

TestLoadingOfTracePlugin();

	RProcess p;

	TBuf<4> driveBuf=_L("?");

	driveBuf[0] = (TText) gDriveToTest;

	test.Next(_L("Test running T_FILE with plugin installed"));

	r = p.Create(_L("T_FILE.exe"), driveBuf);

	test(r==KErrNone);

	TRequestStatus status;

	p.Logon(status);

	p.Resume();

	User::WaitForRequest(status);

TestUnloadingOfTracePlugin();

#endif // __WINS__

	// Cannot format drive C: so skip this test on that drive

	if (!F32_Test_Utils::Is_Win32(TheFs, EDriveC))

	    {

        TestLoadingOfFormatPlugin();

        TestFormatDriveIntercept();

        TestUnloadingOfFormatPlugin();

        TestFormatDriveAfterFormatPlugin();

        }

	}