// Copyright (c) 1996-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\server\t_raw.cpp

//

//

#define __E32TEST_EXTENSION__

#include <f32file.h>

#include <e32test.h>

#include "t_server.h"

#include "fs_utils.h"

#include "fat_utils.h"

using namespace Fat_Test_Utils;

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

LOCAL_D TInt gDrive;

LOCAL_C void Test1()

//

// Test all methods

//

	{

	test.Start(_L("Test all methods"));

	RRawDisk rd;

	TInt r=rd.Open(TheFs,gDrive);

	test_KErrNone(r);

	TBuf8<16> buf;

	r=rd.Read(0,buf);

	test_KErrNone(r);

	r=rd.Write(0,buf);

	test_KErrNone(r);

	rd.Close();

	test.End();

	}

LOCAL_C void Test2()

//

// Test cannot open a RRawDisk while other resources are open on it.

//

	{

	MakeFile(_L("TRAW.TST"));

	MakeDir(_L("\\F32-TST\\TRAW\\TRAWTEST\\"));

	RFile f;

	TInt r=f.Open(TheFs,_L("TRAW.TST"),EFileWrite);

	test_KErrNone(r);

	RRawDisk rd;

	r=rd.Open(TheFs,gDrive);

	test_Value(r, r == KErrInUse);

	f.Close();

	r=rd.Open(TheFs,gDrive);

	test_KErrNone(r);

	rd.Close();

	TFileName fileName;

	r=f.Temp(TheFs,_L(""),fileName,EFileWrite);

	test_KErrNone(r);

	r=rd.Open(TheFs,gDrive);

	test_Value(r, r == KErrInUse);

	f.Close();

	r=rd.Open(TheFs,gDrive);

	test_KErrNone(r);

	rd.Close();

	RDir d;

	r=d.Open(TheFs,_L("TRAWTEST"),KEntryAttNormal);

	test_KErrNone(r);

	r=rd.Open(TheFs,gDrive);

	test_Value(r, r == KErrInUse);

	d.Close();

	r=rd.Open(TheFs,gDrive);

	test_KErrNone(r);

	rd.Close();

    RFormat fmt;

    TInt count;

    r=fmt.Open(TheFs,gSessionPath,EQuickFormat,count);

    test_KErrNone(r);

    r=rd.Open(TheFs,gDrive); // Raw disk access ok during formatting

    test.Printf(_L("open rd when fmt opn r=%d"),r);

	test_Value(r, r == KErrInUse);

    fmt.Close();

    r=rd.Open(TheFs,gDrive);

	test.Printf(_L("open rd when fmt closed r=%d"),r);

    test_KErrNone(r);

	RRawDisk rd2;

	r=rd2.Open(TheFs,gDrive);	//should only have one Raw object open

	test_Value(r, r == KErrInUse);

	rd2.Close();

    rd.Close();

	}

LOCAL_C void Test3()

//

// Test cannot open resources on a disk while raw access is taking place

//

	{

	MakeFile(_L("TRAW.TST"));

	MakeDir(_L("TRAW"));

	RRawDisk rd;

	TInt r=rd.Open(TheFs,gDrive);

	test_KErrNone(r);

	RFile f;

	TFileName fileName;

	r=f.Open(TheFs,_L("TRAW.TST"),EFileWrite);

	test_Value(r, r == KErrInUse);

	r=f.Temp(TheFs,_L(""),fileName,EFileWrite);

	test_Value(r, r == KErrInUse);

	RDir d;

	r=d.Open(TheFs,_L("TRAW"),KEntryAttNormal);

	test_Value(r, r == KErrInUse);

	RFormat fmt;

	TInt count;

	r=fmt.Open(TheFs,gSessionPath,EQuickFormat,count);

    if (r != KErrInUse)

        test.Printf(_L("Error %d. Sess = %S"), r, &gSessionPath);

	test_Value(r, r == KErrInUse);

	CDir* dir=(CDir*)0x05;

	r=TheFs.GetDir(_L("\\F32-TST\\*.*"),KEntryAttNormal,ESortNone,dir);

	test_Value(r, r == KErrInUse);

	test(dir==NULL);

	RRawDisk rd2;

	r=rd2.Open(TheFs,gDrive);

	test_Value(r, r == KErrInUse);

//	fmt.Close();

	rd.Close();

//	rd2.Close();

	}

LOCAL_C void Test4()

//

// Test Read and Write

//

	{

	TBuf8<32> contents=_L8("This File says BOO");

	MakeFile(_L("TRAW.TST"),contents);

	RRawDisk rd;

	TInt r=rd.Open(TheFs,gDrive);

	test_KErrNone(r);

	TBuf8<32> textBuf;

	TInt64 pos=0;

	test.Printf(_L("doing rawread"));

	FOREVER

		{

		r=rd.Read(pos,textBuf);

		if (r!=KErrNone)

			{

			test.Printf(_L("ERROR: RawDisk read returned %d at pos %ld"),r, pos);

			test(0);

			//test.Getch();

			break;

			}

		if ((pos % (1024*1024)) == 0)

			test.Printf(_L("Read position 0x%x            \r"), pos);

		textBuf.SetLength(contents.Length());

		if (textBuf==contents)

			break;

		pos+=512;

		}

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

	TBuf8<32> contents2=_L8("This File says MOO");

	r=rd.Write(pos,contents2);

	test_KErrNone(r);

	rd.Close();

	RFile f;

	r=f.Open(TheFs,_L("TRAW.TST"),EFileRead);

	test_KErrNone(r);

	r=f.Read(textBuf);

	test_KErrNone(r);

	test(textBuf==contents2);

	f.Close();

	}

enum TTestCommands

	{

	EThreadForgetToCloseSession,

	EThreadForgetToCloseRaw,

	EThreadHang

	};

RSemaphore gSemaphore;

TInt MyThreadFunction(TAny* aThreadCommand)

//

// Do nasty things

//

	{

	RRawDisk rd;

	RFs fs;

	TInt r=fs.Connect();

	if (r!=KErrNone)

		goto Error;

	r=rd.Open(fs,gDrive);

	if (r!=KErrNone)

		goto Error;

	switch((TTestCommands)(TInt)aThreadCommand)

		{

	case EThreadForgetToCloseSession:

		return(KErrNone);

	case EThreadForgetToCloseRaw:

		break;

	case EThreadHang:

		gSemaphore.Signal();

		FOREVER{};

	default:

		goto Error;

		}

	fs.Close();

	return(KErrNone);

Error:

	User::Panic(_L("Shouldn't be here!"),0);

	return(KErrNone);

	}

LOCAL_C void Test5()

//

// Test thread panics

//

	{

	test.Next(_L("Test thread panics"));

	MakeFile(_L("TEST.FILE"));

	RThread thread;

	TInt r=thread.Create(_L("MyThread"),MyThreadFunction,0x1000,0x1000,0x1000,(TAny*)EThreadForgetToCloseSession);

	test_KErrNone(r);

	TRequestStatus reqStat;

	thread.Logon(reqStat);

	thread.Resume();

	User::WaitForRequest(reqStat);

	CLOSE_AND_WAIT(thread);

	// We know the disconnect has been sent to the file server by this point

	// but we don't know it has been processed.

	// Connect and disconnect a session here to make sure.

	FsBarrier();

	RFile f;

	r=f.Open(TheFs,_L("TEST.FILE"),EFileWrite);

	test_KErrNone(r);

	f.Close();

	r=thread.Create(_L("MyThread"),MyThreadFunction,0x1000,0x1000,0x1000,(TAny*)EThreadForgetToCloseRaw);

	test_KErrNone(r);

	thread.Logon(reqStat);

	thread.Resume();

	User::WaitForRequest(reqStat);

	CLOSE_AND_WAIT(thread);

	// We know the disconnect has been sent to the file server by this point

	// but we don't know it has been processed.

	// Connect and disconnect a session here to make sure.

	FsBarrier();

	r=f.Open(TheFs,_L("TEST.FILE"),EFileWrite);

	test_KErrNone(r);

	f.Close();

	r=gSemaphore.CreateGlobal(_L("MySemaphore"),0);

	test_KErrNone(r);

	r=thread.Create(_L("MyThread"),MyThreadFunction,0x1000,0x1000,0x1000,(TAny*)EThreadHang);

	test_KErrNone(r);

	thread.Resume();

	gSemaphore.Wait();

	gSemaphore.Close();

	r=f.Open(TheFs,_L("TEST.FILE"),EFileWrite);

	test_Value(r, r == KErrInUse);

	TBool jit = User::JustInTime();

	User::SetJustInTime(EFalse);

	thread.Kill(KErrGeneral);

	CLOSE_AND_WAIT(thread);

	User::SetJustInTime(jit);

	// We know the disconnect has been sent to the file server by this point

	// but we don't know it has been processed.

	// Connect and disconnect a session here to make sure.

	FsBarrier();

	r=f.Open(TheFs,_L("TEST.FILE"),EFileWrite);

	test_KErrNone(r);

	f.Close();

	}

GLDEF_C void CallTestsL()

//

// Do all tests

//

	{

    //-- set up console output

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

	TInt r=TheFs.CharToDrive(gSessionPath[0],gDrive);

	test_KErrNone(r);

    PrintDrvInfo(TheFs, gDrive);

    //-- check if this is FAT

    if(!Is_Fat(TheFs, gDrive))

    {

        test.Printf(_L("Skipping. This test requires FAT drive.\n"));

        return;

    }

    //-- format the drive.

    r = FormatFatDrive(TheFs, gDrive, ETrue);

    test_KErrNone(r);

	CreateTestDirectory(_L("\\F32-TST\\TRAW\\"));

	Test1();

	Test2();

	Test3();

	Test4(); // (silly test) Not valid on LFFS

    Test5();

	DeleteTestDirectory();

	}