// 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:
//


#include <e32def.h>
#include <e32cmn.h>
#include <e32base.h>
#include <f32file.h>
#include <e32cons.h>
#include <e32debug.h>
#define __E32TEST_EXTENSION__
#include <e32test.h>
#include <e32property.h>

#include "f32_test_utils.h"

#include "cblockdevicetester.h"
#include "cmsdrive.h"
#include "tmsprintdrive.h"
#include "ttestutils.h"
#include "tmslog.h"

using namespace F32_Test_Utils;

extern CMsDrive* msDrive;

RTest test(_L("T_MSBLOCK"));
RFs fsSession;


class TTestMsBlock
    {
public:
    void tFileAccess();
    void tBlockAccessL();
    void tRawAccessL();
    void tLastLbaAccessL();
    };


void TTestMsBlock::tFileAccess()
    {
    test.Start(_L("tFileAccess\n"));

    test.Next(_L("DriveInfo"));
    PrintDrvInfo(fsSession, msDrive->DriveNumber());

    TVolumeInfo volInfo;
    TInt err = fsSession.Volume(volInfo);
    test(err == KErrNone);

    test.Printf(_L("Memory 'in use' = %lx\n"), (volInfo.iSize - volInfo.iFree));
    test.Printf(_L("volInfo.iSize = %lx\n"), volInfo.iSize);
    test.Printf(_L("volInfo.iFree = %lx\n"), volInfo.iFree);

    //-- 1. create a file
    _LIT(KFile, "\\test_file.file");
    const TUint KFileSz = 54321;

    test.Next(_L("Write file\n"));
    err = CreateCheckableStuffedFile(fsSession, KFile, KFileSz);
    test_KErrNone(err);

    //-- 2. verify the file, just in case.
    test.Next(_L("Verify file\n"));
    err = VerifyCheckableFile(fsSession, KFile);
    test_KErrNone(err);

    //-- 3. delete the file
    test.Next(_L("Delete file\n"));
    fsSession.Delete(KFile);
    test.End();
    }

void TTestMsBlock::tBlockAccessL()
    {
    test.Start(_L("tBlockAccess\n"));

    test.Next(_L("Create Test drive\n"));
    TInt driveNumber = msDrive->DriveNumber();
    CBlockDeviceTester* blockDeviceTester = CBlockDeviceTester::NewL(driveNumber);

    test.Next(_L("Verify Test area on drive\n"));
    TInt res = blockDeviceTester->VerifyDrive();
    test_KErrNone(res);

    test.Next(_L("Test Single Block access\n"));
    TLba lba = 1;
    TLba blocks = 1;

    test.Printf(_L("write block LBA=0x%x Blocks=0x%x\n"),lba, blocks);
    res = blockDeviceTester->UpdateBlock(lba, blocks);
    test_KErrNone(res);

    test.Printf(_L("read block LBA=0x%x Blocks=0x%x\n"),lba, blocks);
    res = blockDeviceTester->VerifyBlock(lba, blocks);
    test_KErrNone(res);

    test.Printf(_L("Verify drive\n"));
    res = blockDeviceTester->VerifyDrive();
    test_KErrNone(res);

    test.Next(_L("Test Multiple Block access\n"));
    lba = 6;
    blocks = 7;
    res = blockDeviceTester->UpdateBlock(lba, blocks);
    test_KErrNone(res);
    res = blockDeviceTester->VerifyBlock(lba, blocks);
    test_KErrNone(res);
    res = blockDeviceTester->VerifyDrive();
    test_KErrNone(res);

    delete blockDeviceTester;
    test.End();
    }

void TTestMsBlock::tRawAccessL()
    {
    test.Start(_L("tRawAccess\n"));

    // Head
    const TPos KPos_H = (KBlockSize * 5) + 0x7;
    const TUint KLen_H = 0x123;

    // Head + Tail
    const TPos KPos_HT = (KBlockSize * 7) + 0x180;
    const TUint KLen_HT = 0x100;

    // Head + Body + Tail
    const TPos KPos_HBT = (KBlockSize * 9) + 0x190;
    const TUint KLen_HBT = (KBlockSize * 4) + 0x110;


    test.Next(_L("Create Test drive\n"));
    TInt driveNumber = msDrive->DriveNumber();
    CBlockDeviceTester* blockDeviceTester = CBlockDeviceTester::NewL(driveNumber);

    test.Next(_L("Verify Test area on drive\n"));
    TInt res = blockDeviceTester->VerifyDrive();
    test_KErrNone(res);


    TPos pos = KPos_H;
    TUint len = KLen_H;
    test.Next(_L("Test head access\n"));
    test.Printf(_L("Pos=0x%lx Len=0x%x\n"), pos, len);
    res = blockDeviceTester->Update(pos, len);
    test_KErrNone(res);
    res = blockDeviceTester->Verify(pos, len);
    test_KErrNone(res);
    res = blockDeviceTester->VerifyDrive();
    test_KErrNone(res);

    pos = KPos_HT;
    len = KLen_HT;
    test.Next(_L("Test head + tail access\n"));
    test.Printf(_L("Pos=0x%lx Len=0x%x\n"), pos, len);
    res = blockDeviceTester->Update(pos, len);
    test_KErrNone(res);
    res = blockDeviceTester->Verify(pos, len);
    test_KErrNone(res);
    res = blockDeviceTester->VerifyDrive();
    test_KErrNone(res);

    pos = KPos_HBT;
    len = KLen_HBT;
    test.Next(_L("Test head + body+ tail access\n"));
    test.Printf(_L("Pos=0x%lx Len=0x%x\n"), pos, len);
    res = blockDeviceTester->Update(pos, len);
    test_KErrNone(res);
    res = blockDeviceTester->Verify(pos, len);
    test_KErrNone(res);
    res = blockDeviceTester->VerifyDrive();
    test_KErrNone(res);

    delete blockDeviceTester;
    test.End();
    }


void TTestMsBlock::tLastLbaAccessL()
    {
    test.Start(_L("tLastLbaAccess\n"));
    test.Next(_L("tLastLbaAccess\n"));

    TInt driveNumber = msDrive->DriveNumber();

    TVolumeInfo volInfo;
    TInt err = fsSession.Volume(volInfo);
    test(err == KErrNone);

    test.Printf(_L("Memory 'in use' = 0x%lx (0x%x)\n"),
                (volInfo.iSize - volInfo.iFree), (volInfo.iSize - volInfo.iFree)/KBlockSize);
    test.Printf(_L("volInfo.iSize   = 0x%lx (0x%x)\n"),
                volInfo.iSize, volInfo.iSize/KBlockSize);
    test.Printf(_L("volInfo.iFree   = 0x%lx (0x%x)\n"),
                volInfo.iFree, volInfo.iFree/KBlockSize);

    TLba lba = volInfo.iSize/KBlockSize;
    RBlockTargetMedia media(driveNumber);
    media.OpenL();

    TInt writeRes = KErrNone;
    TInt readRes = KErrNone;
    test.Printf(_L("LBA=%x\n"), lba);
    for (;writeRes == KErrNone && readRes == KErrNone; lba++)
        {
        writeRes = media.WriteBlock(lba);
        readRes = media.ReadBlock(lba);
        }

    test.Printf(_L("LBA=%x ERR Write=%d Read=%d\n"), lba, writeRes, readRes);

    media.Close();
    test.End();
    }

void CallTestsL()
    {
    TTestMsBlock t;
    t.tFileAccess();
    t.tBlockAccessL();
    t.tRawAccessL();
    t.tLastLbaAccessL();
    }