// Copyright (c) 2002-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\ext\t_ext1.cpp

// 

//

#define __E32TEST_EXTENSION__

#include <f32file.h>

#include <e32test.h>

#include <e32svr.h>

#include "t_server.h"

#include "f32_test_utils.h"

using namespace F32_Test_Utils;

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

_LIT(KExtensionLog,"T_LOGEXT");

_LIT(KExtensionLogName,"Logger");

_LIT(KExtensionEmpty,"T_EMPTYEXT");

_LIT(KExtensionEmptyName,"Empty");

_LIT(KExtensionBit,"T_BITEXT");

_LIT(KExtensionBitName,"Bitchange");

_LIT(KExtensionRubbish,"T_RUBBISH");

_LIT(dir1,"\\dir1\\");

_LIT(file1Name,"\\dir1\\file1.doc");

_LIT8(toWrite,"abcdefghijklmnop");

void TestSecondaryExtensions()

//

// a secondary extension is one that is added to a drive with an existing file system

// therefore a mount is successful with or without the extension

//

	{

	test.Next(_L("TestSecondaryExtensions()"));

	TInt drive;

	TInt err=RFs::CharToDrive(gDriveToTest,drive);

	test_KErrNone(err);

	TPckgBuf<TBool> drvSyncBuf;

	err = TheFs.QueryVolumeInfoExt(drive, EIsDriveSync, drvSyncBuf);

	test_KErrNone(err);

	const TBool bDrvSync = drvSyncBuf();

	TFullName fsName;

	TInt r=TheFs.FileSystemName(fsName,drive);

	test_KErrNone(r);

	test.Printf(_L("fsName=%S\n"),&fsName);

	if (Is_SimulatedSystemDrive(TheFs, drive))

		{

		// check that the extension cannot be mounted since it is not supported by the file system

		test.Printf(_L("Test extension cannot be mounted"));

		r=TheFs.AddExtension(KExtensionLog);

		test_KErrNone(r);

		r=TheFs.MountExtension(KExtensionLogName,drive);

		test_Value(r, r == KErrNotSupported);

		r=TheFs.RemoveExtension(KExtensionLogName);

		test_KErrNone(r);

		return;

		}

	test.Next(_L("RFs::AddExtension()"));

	r=TheFs.AddExtension(KExtensionLog);

	RDebug::Print(_L("addext=%d"),r);

	test_KErrNone(r);

	r=TheFs.AddExtension(KExtensionLog);

	test_Value(r, r == KErrAlreadyExists);

	r=TheFs.AddExtension(KExtensionRubbish);

	test_Value(r, r == KErrNotFound);

	r=TheFs.AddExtension(KExtensionEmpty);

	test_KErrNone(r);

	test.Next(_L("RFs::MountExtension()"));

#if !defined(__WINS__)

	// check that the extension cannot be mounted on file system that does not support extensions

	r=TheFs.MountExtension(KExtensionLogName,EDriveZ);

	test_Value(r, r == KErrNotSupported);

#endif

	// test mounting on drive with no file system

	r=TheFs.DismountFileSystem(fsName,drive);

	test_KErrNone(r);

	r=TheFs.MountExtension(KExtensionLogName,drive);

	test_Value(r, r == KErrNotReady);

	r=TheFs.MountFileSystem(fsName,drive,bDrvSync);

	test_KErrNone(r);

	// test with a resource open

	_LIT(KFileName,"testing.doc");

	RFile file;

	r=file.Replace(TheFs,KFileName,EFileShareExclusive);

	test_KErrNone(r);

	r=TheFs.MountExtension(KExtensionLogName,drive);

	test_Value(r, r == KErrInUse);

	file.Close();

	r=TheFs.Delete(KFileName);

	test_KErrNone(r);

	// test with a format open

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

	driveBuf[0]=(TText)(drive+'A');

	RFormat format;

	TInt count;

	r=format.Open(TheFs,driveBuf,EHighDensity,count);

	test_KErrNone(r);

	r=TheFs.MountExtension(KExtensionLogName,drive);

	test_Value(r, r == KErrInUse);

	format.Close();

	// get the extension name

	TFullName extName;

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

	test_Value(r, r == KErrNotFound);

	// now load the extension

	r=TheFs.MountExtension(KExtensionLogName,drive);

	test_KErrNone(r);

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

	test_Value(r, r == KErrNone && extName==KExtensionLogName);

	r=TheFs.ExtensionName(extName,drive,1);

	test_Value(r, r == KErrNotFound);

	// try remounting the same extension

	r=TheFs.MountExtension(KExtensionLogName,drive);

	test_Value(r, r == KErrAlreadyExists);

	// mount a second extension

	r=TheFs.MountExtension(KExtensionEmptyName,drive);

	test_KErrNone(r);

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

	test_Value(r, r == KErrNone && extName==KExtensionLogName);

	r=TheFs.ExtensionName(extName,drive,1);

	test_Value(r, r == KErrNone && extName==KExtensionEmptyName);

    // force a remount on a removable media and check that extensions both exist

    test.Printf(_L("Test forcing remount\n"));

    TDriveInfo info;

	r=TheFs.Drive(info,drive);

	if(info.iDriveAtt&KDriveAttRemovable)

		{

        const TInt KMediaRemountForceMediaChange = 0x00000001;

        TRequestStatus changeStatus;

        TheFs.NotifyChange(ENotifyAll, changeStatus);

        test.Printf(_L("Remounting the drive\n"), r);

        r = TheFs.RemountDrive(drive, NULL, (TUint) KMediaRemountForceMediaChange);

        test_Value(r, r == KErrNotReady || r == KErrNone);

        do

        {

        test.Printf(_L("Waiting for media change...\n"));

        User::WaitForRequest(changeStatus);

        r=TheFs.Drive(info,drive);

        test.Printf(_L("Drive() returned %d\n"), r);

        TheFs.NotifyChange(ENotifyAll, changeStatus);

        }

    while (r == KErrNotReady);

    TheFs.NotifyChangeCancel(changeStatus);

    User::After(1000000); //-- don't know why we need this, otherwise for WINS mediadriver returns -18

/*	

        //-- strange, but this variant caused Media Driver to always return -18 

        //-- and the media have become inaccessible forever (on H2). 

        //-- funny enough, but turning ON heavy logging from the drivers (PBUS & KLOCDRV) helped the problem

        test.Printf(_L("Force media change\n"));

    	RLocalDrive d;

		TBool flag=EFalse;

		r=d.Connect(1,flag);

		test_KErrNone(r);

		d.ForceMediaChange();

		d.Close();

//#if defined(__WINS__)

		// ??? seems to work, find out why

		//User::After(500000);

        User::After(2000000);

//#endif

*/

		}

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

	test_Value(r, r == KErrNone && extName==KExtensionLogName);

	r=TheFs.ExtensionName(extName,drive,1);

	test_Value(r, r == KErrNone && extName==KExtensionEmptyName);

    test.Printf(_L("Accessing media...\n"));

	// and now do some file system operations

	TBuf8<16> readBuf;

	r=TheFs.MkDir(dir1);

    test.Printf(_L("res=%d\n"), r);

	test_Value(r, r == KErrNone||r==KErrAlreadyExists);

	RFile file1;

	r=file1.Replace(TheFs,file1Name,EFileShareExclusive);

	test_KErrNone(r);

	r=file1.Write(toWrite);

	test_KErrNone(r);

	r=file1.Read(0,readBuf);

	test(readBuf==toWrite);

	r=file1.SetSize(0);

	test_KErrNone(r);

	file1.Close();

	r=TheFs.Delete(file1Name);

	test_KErrNone(r);

	r=TheFs.RmDir(dir1);

	test_KErrNone(r);

	test.Next(_L("RFs::DismountExtension()"));

	// test with a resource open

	r=file.Replace(TheFs,KFileName,EFileShareExclusive);

	test_KErrNone(r);

	r=TheFs.DismountExtension(KExtensionLogName,drive);

	test_Value(r, r == KErrInUse);

	file.Close();

	r=TheFs.Delete(KFileName);

	test_KErrNone(r);

	// test with a format open

	r=format.Open(TheFs,driveBuf,EHighDensity,count);

	test_KErrNone(r);

	r=TheFs.DismountExtension(KExtensionLogName,drive);

	test_Value(r, r == KErrInUse);

	format.Close();

	// now dismount an extension

	r=TheFs.DismountExtension(KExtensionLogName,drive);

	test_KErrNone(r);

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

	test_Value(r, r == KErrNone && extName==KExtensionEmptyName);

	r=TheFs.ExtensionName(extName,drive,1);

	test_Value(r, r == KErrNotFound);

	// try to dismount an extension that is not mounted

	r=TheFs.DismountExtension(KExtensionLogName,drive);

	test_Value(r, r == KErrNotFound);

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

	test_Value(r, r == KErrNone && extName==KExtensionEmptyName);

	r=TheFs.ExtensionName(extName,drive,1);

	test_Value(r, r == KErrNotFound);

	// dismount the remaining extension

	r=TheFs.DismountExtension(KExtensionEmptyName,drive);

	test_KErrNone(r);

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

	test_Value(r, r == KErrNotFound);

	r=TheFs.ExtensionName(extName,drive,1);

	test_Value(r, r == KErrNotFound);

	test.Next(_L("RFs::RemoveExtension()"));

	r=TheFs.RemoveExtension(KExtensionLogName);

	test_KErrNone(r);

	r=TheFs.RemoveExtension(KExtensionEmptyName);

	test_KErrNone(r);

	}

void TestPrimaryExtensions()

//

// a primary extension is one that is added to a drive before a file system is mounted

// must be present for the mount to be successful (eg. FTL)

//

	{

	test.Next(_L("TestPrimaryExtensions()"));

	TInt drive;

	TInt err=RFs::CharToDrive(gDriveToTest,drive);

	test_KErrNone(err);

	if(Is_SimulatedSystemDrive(TheFs, drive))

	    {

		test.Printf(_L("Skipping TestPrimaryExtensions on PlatSim/Emulator drive %C:\n"), gSessionPath[0]);

		return;

	    }

	TPckgBuf<TBool> drvSyncBuf;

	err = TheFs.QueryVolumeInfoExt(drive, EIsDriveSync, drvSyncBuf);

	test_KErrNone(err);

    const TBool bDrvSync = drvSyncBuf();

	// don't test on ram drive since accesses memory directly

	TDriveInfo info;

	TInt r=TheFs.Drive(info,drive);

	if(info.iMediaAtt&KMediaAttVariableSize)

		return;

	TFullName fsName;

	r=TheFs.FileSystemName(fsName,drive);

	test_KErrNone(r);

	test.Printf(_L("fsName=%S\n"),&fsName);

	test.Next(_L("RFs::AddExtension()"));

	r=TheFs.AddExtension(KExtensionLog);

	test_KErrNone(r);

	r=TheFs.AddExtension(KExtensionEmpty);

	test_KErrNone(r);

	r=TheFs.AddExtension(KExtensionBit);

	test_KErrNone(r);

	test.Next(_L("RFs::MountFileSystem()"));

	// test with file system that already exists

	r=TheFs.MountFileSystem(fsName,KExtensionBitName,drive,bDrvSync);

	test_Value(r, r == KErrAccessDenied);

	// unmount drive and mount primary extension along with file system

	r=TheFs.DismountFileSystem(fsName,drive);

	test_KErrNone(r);

    //-- !! N.B this extension mangles data read/written ftom/to the media, for some file systems it is OK and mounting succeeds

    //-- for others - this will result in KErrCorrupt

	r=TheFs.MountFileSystem(fsName,KExtensionBitName,drive,bDrvSync);

	test_Value(r, r == KErrNone||r==KErrCorrupt);

    // and now format

	Format(drive);

	TFullName extName;

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

	test_Value(r, r == KErrNone && extName==KExtensionBitName);

	r=TheFs.ExtensionName(extName,drive,1);

	test_Value(r, r == KErrNotFound);

	// and now do some file system operations

	TBuf8<16> readBuf;

	r=TheFs.MkDir(dir1);

	test_Value(r, r == KErrNone||r==KErrAlreadyExists);

	RFile file1;

	r=file1.Replace(TheFs,file1Name,EFileShareExclusive);

	test_KErrNone(r);

	r=file1.Write(toWrite);

	test_KErrNone(r);

	r=file1.Read(0,readBuf);

	test(readBuf==toWrite);

	r=file1.SetSize(0);

	test_KErrNone(r);

	file1.Close();

	r=TheFs.Delete(file1Name);

	test_KErrNone(r);

	r=TheFs.RmDir(dir1);

	test_KErrNone(r);

	// add a secondary extension

	test.Printf(_L("RFs::MountExtension()"));

	r=TheFs.MountExtension(KExtensionLogName,drive);

	test_KErrNone(r);

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

	test_Value(r, r == KErrNone && extName==KExtensionBitName);

	r=TheFs.ExtensionName(extName,drive,1);

	test_Value(r, r == KErrNone && extName==KExtensionLogName);

	// try to add the same extension

	r=TheFs.MountExtension(KExtensionBitName,drive);

	test_Value(r, r == KErrAlreadyExists);

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

	test_Value(r, r == KErrNone && extName==KExtensionBitName);

	r=TheFs.ExtensionName(extName,drive,1);

	test_Value(r, r == KErrNone && extName==KExtensionLogName);

	// try to add a third extension

	r=TheFs.MountExtension(KExtensionEmptyName,drive);

	test_Value(r, r == KErrAccessDenied);

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

	test_Value(r, r == KErrNone && extName==KExtensionBitName);

	r=TheFs.ExtensionName(extName,drive,1);

	test_Value(r, r == KErrNone && extName==KExtensionLogName);

	// and now do some file system operations

	r=TheFs.MkDir(dir1);

	test_Value(r, r == KErrNone||r==KErrAlreadyExists);

	r=file1.Replace(TheFs,file1Name,EFileShareExclusive);

	test_KErrNone(r);

	r=file1.Write(toWrite);

	test_KErrNone(r);

	r=file1.Read(0,readBuf);

	test(readBuf==toWrite);

	r=file1.SetSize(0);

	test_KErrNone(r);

	file1.Close();

	r=TheFs.Delete(file1Name);

	test_KErrNone(r);

	r=TheFs.RmDir(dir1);

	test_KErrNone(r);

	test.Printf(_L("RFs::DismountExtension()"));

	// test that can't dismount a primary extension via this method

	r=TheFs.DismountExtension(KExtensionLogName,drive);

	test_KErrNone(r);

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

	test_Value(r, r == KErrNone && extName==KExtensionBitName);

	r=TheFs.ExtensionName(extName,drive,1);

	test_Value(r, r == KErrNotFound);

	r=TheFs.DismountExtension(KExtensionBitName,drive);

	test_Value(r, r == KErrAccessDenied);

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

	test_Value(r, r == KErrNone && extName==KExtensionBitName);

	r=TheFs.ExtensionName(extName,drive,1);

	test_Value(r, r == KErrNotFound);

	test.Printf(_L("RFs::DismountFileSystem()"));

	r=TheFs.MountExtension(KExtensionLogName,drive);

	test_KErrNone(r);

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

	test_Value(r, r == KErrNone && extName==KExtensionBitName);

	r=TheFs.ExtensionName(extName,drive,1);

	test_Value(r, r == KErrNone && extName==KExtensionLogName);

	// and now dismount

	r=TheFs.DismountFileSystem(fsName,drive);

	test_KErrNone(r);

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

	test_Value(r, r == KErrNotReady);

	r=TheFs.ExtensionName(extName,drive,1);

	test_Value(r, r == KErrNotReady);

	// remount the file system

	r=TheFs.MountFileSystem(fsName,drive,bDrvSync);

	test_Value(r, r == KErrNone||r==KErrCorrupt);

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

	test_Value(r, r == KErrNotFound);

	r=TheFs.ExtensionName(extName,drive,1);

	test_Value(r, r == KErrNotFound);

	Format(drive);

	test.Next(_L("RFs::RemoveExtension()"));

	r=TheFs.RemoveExtension(KExtensionLogName);

	test_KErrNone(r);

	r=TheFs.RemoveExtension(KExtensionEmptyName);

	test_KErrNone(r);

	r=TheFs.RemoveExtension(KExtensionBitName);

	test_KErrNone(r);

	}

GLDEF_C void CallTestsL()

//

// Do tests relative to the session path

//

	{

    //-- set up console output 

    F32_Test_Utils::SetConsole(test.Console()); 

    TInt drive;

	TInt err=RFs::CharToDrive(gDriveToTest,drive);

	test.Start(_L("Starting Test - T_EXT1"));

	test_KErrNone(err);

	// Check that the drive supports extensions.

	TBool extensionsSupported = EFalse;

	TPckg<TBool> dataBuf(extensionsSupported);

	err = TheFs.QueryVolumeInfoExt(drive,EFSysExtensionsSupported,dataBuf);

	test_KErrNone(err);

	if(!extensionsSupported)

	    {

        test.Printf(_L("Drive %C: does not support file sys extensions. Skipping T_EXT1."), gSessionPath[0]);

        test.End();

        test.Close();

        return;

	    }

    PrintDrvInfo(TheFs, drive);

//Do not run this test on the NAND drive, as

//this has the FTL mounted as a primary extension

//which causes the test to fail

#if defined(__WINS__)

	if (drive==EDriveU)

		return;

#else

	TDriveInfo driveInfo;

	TheFs.Drive(driveInfo,drive);

	if (driveInfo.iType == EMediaNANDFlash)

		{

		test.Printf(_L("Skipping T_EXT1 as drive %C: is NAND\n"), gSessionPath[0]);

		return;

		}

#endif

	TestSecondaryExtensions();

    //-- the t_bitext extension mangles data from the media, which may make FS mounting fail because of "corrupted" data. 

    //-- Then this step formats the media, automounter doesn't support it straightforward way

    if(!Is_Lffs(TheFs, drive) && !Is_Automounter(TheFs, drive))

		{

		TestPrimaryExtensions();

		}

	test.End();

	test.Close();

	}