diff -r a179b74831c9 -r c1f20ce4abcf kerneltest/f32test/filesystem/fat/t_nonrugged.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/kerneltest/f32test/filesystem/fat/t_nonrugged.cpp Tue Aug 31 16:34:26 2010 +0300 @@ -0,0 +1,295 @@ +// Copyright (c) 2009-2010 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\filesystem\fat\t_nonrugged.cpp +// Functional tests for the non-Rugged file mode (also called the File Sequential mode) +// Only perform tests on the Rugged FAT file system +// + +#define __E32TEST_EXTENSION__ + +#include +#include + +#include "t_server.h" +#include "fat_utils.h" +using namespace Fat_Test_Utils; + + +RTest test(_L("T_NONRUGGED")); + +TInt gDriveNum; + +_LIT(KTestPath, ":\\F32-TST\\T_NONRUGGED\\"); // 22 + + +enum TNonRuggedFileMode + { + ENormalFileMode, // File is in normal (Rugged) mode + ENonRuggedFileMode // File is in non-Rugged file mode (EFileSequential) + }; + +enum TNonRuggedControlIO +/* + * ControlIo enum values + */ + { + EControlIOIsRuggedFSys = 4, // Defined as EIsRuggedFSys in \fileserver\sfat32\common_constants.h + EControlIOIsFileSequential = KMaxTInt-23 // Defined as KControlIoIsFileSequential in \fileserver\inc\f32dbg.h + }; + + +void CreateFile(RFile& aFile, const TDesC& aPath, TUint aFileMode) +/* + * Creates/opens a file in Rugged/non-Rugged mode after emptying the trace buffer + */ + { + TInt r = TheFs.MkDirAll(aPath); + test_Value(r, r == KErrNone || r == KErrAlreadyExists); + r = aFile.Replace(TheFs, aPath, aFileMode); + test_KErrNone(r); + } + + +void DeleteFileAndDir(const TDesC& aPath) +/* + * Deletes a single file and the directory containing it + */ + { + TInt r = TheFs.Delete(aPath); + test_KErrNone(r); + r = TheFs.RmDir(aPath); + test_KErrNone(r); + } + + +void SingleClientTest() +/* + * Unit test for Non-Rugged File mode with a single client + *********************************************************************************** + * 1. Create a file in non-Rugged file mode and then close the file. + * 2. Open the file in normal Rugged file mode and then close it. + * 3. Open the file in non-Rugged file mode again and then close it. + * Expected Results: + * 1. File is in non-Rugged file mode. + * 2. File is in normal Rugged file mode. + * 3. File is in non-Rugged file mode. + *********************************************************************************** + */ + { + test.Next(_L("Test single client")); + + TBuf<34> singleFile; + singleFile.Append(gDriveToTest); // 1 + singleFile.Append(KTestPath); // 22 + singleFile.Append(_L("file.single")); // 11 + TInt r = TheFs.Delete(singleFile); + test_Value(r, r == KErrNone || r == KErrNotFound || r == KErrPathNotFound); + TBuf8 singleFilePkg; + singleFilePkg.Copy(singleFile.Mid(2)); + TUint8 fileMode = 0; + TPtr8 fileModePkg(&fileMode, 1, 1); + + test.Printf(_L("Create file in non-Rugged file mode\n")); + RFile file; + CreateFile(file, singleFile, (EFileWrite | EFileSequential)); + r = TheFs.ControlIo(gDriveNum, EControlIOIsFileSequential, singleFilePkg, fileModePkg); + test_KErrNone(r); + test_Equal(ENonRuggedFileMode, fileMode); + file.Close(); + + test.Printf(_L("Open file in normal mode\n")); + CreateFile(file, singleFile, EFileWrite); + r = TheFs.ControlIo(gDriveNum, EControlIOIsFileSequential, singleFilePkg, fileModePkg); + test_KErrNone(r); + test_Equal(ENormalFileMode, fileMode); + file.Close(); + + test.Printf(_L("Open file in non-Rugged file mode again\n")); + CreateFile(file, singleFile, (EFileWrite | EFileSequential)); + r = TheFs.ControlIo(gDriveNum, EControlIOIsFileSequential, singleFilePkg, fileModePkg); + test_KErrNone(r); + test_Equal(ENonRuggedFileMode, fileMode); + file.Close(); + + DeleteFileAndDir(singleFile); + } + + +void MultipleClientsTest() +/* + * Unit tests for Non-Rugged File mode with multiple clients accessing the same file + */ + { + /*********************************************************************************** + * Use Case 1: + * 1. Client1 opens a file in non-Rugged file mode. + * 2. Client2 then opens the same file in normal Rugged file mode. + * Expected Results: + * 1. File is in non-Rugged file mode. + * 2. File changed to normal Rugged file mode. + *********************************************************************************** + */ + test.Next(_L("Test multiple clients - Use case 1")); + + TBuf<33> fileName1; + fileName1.Append(gDriveToTest); // 1 + fileName1.Append(KTestPath); // 22 + fileName1.Append(_L("file1.mult")); // 10 + TInt r = TheFs.Delete(fileName1); + test_Value(r, r == KErrNone || r == KErrNotFound || r == KErrPathNotFound); + TBuf8<31> fileName1Pkg; + fileName1Pkg.Copy(fileName1.Mid(2)); + TUint8 fileMode = 0; + TPtr8 fileModePkg(&fileMode, 1, 1); + + + // Use Case 1.1, Client 1 (Non-Rugged Client) ------------------------------------ + test.Printf(_L("Client1 create file in non-Rugged file mode\n")); + + RFile file1; + CreateFile(file1, fileName1, (EFileWrite | EFileSequential | EFileShareAny)); + r = TheFs.ControlIo(gDriveNum, EControlIOIsFileSequential, fileName1Pkg, fileModePkg); + test_KErrNone(r); + test_Equal(ENonRuggedFileMode, fileMode); + + + // Use Case 1.2, Client 2 (Rugged Client) ---------------------------------------- + test.Printf(_L("Client2 open file in 'normal' Rugged file mode\n")); + + RFile file2; + CreateFile(file2, fileName1, (EFileWrite | EFileShareAny)); + r = TheFs.ControlIo(gDriveNum, EControlIOIsFileSequential, fileName1Pkg, fileModePkg); + test_KErrNone(r); + test_Equal(ENormalFileMode, fileMode); + + + file1.Close(); + file2.Close(); + r = TheFs.Delete(fileName1); + test_KErrNone(r); + + + /*********************************************************************************** + * Use Case 2: + * 1. Client1 opens a file in normal Rugged file mode. + * 2. Client2 then opens the same file in non-Rugged file mode. + * Expected Results: + * 1. File is in normal Rugged file mode. + * 2. File does not change to non-Rugged file mode. + *********************************************************************************** + */ + test.Next(_L("Test multiple clients - Use case 2")); + + TBuf<34> fileName2; + fileName2.Append(gDriveToTest); // 1 + fileName2.Append(KTestPath); // 22 + fileName2.Append(_L("file2.mult")); // 10 + r = TheFs.Delete(fileName2); + test_Value(r, r == KErrNone || r == KErrNotFound || r == KErrPathNotFound); + TBuf8 fileName2Pkg; + fileName2Pkg.Copy(fileName2.Mid(2)); + + + // Use Case 2.1, Client 1 (Rugged Client) ---------------------------------------- + test.Printf(_L("Client1 create file in 'normal' Rugged file mode\n")); + + CreateFile(file1, fileName2, (EFileWrite | EFileShareAny)); + r = TheFs.ControlIo(gDriveNum, EControlIOIsFileSequential, fileName2Pkg, fileModePkg); + test_KErrNone(r); + test_Equal(ENormalFileMode, fileMode); + + + // Use Case 2.2, Client 2 (Non-Rugged Client) ------------------------------------ + test.Printf(_L("Client2 open file in non-Rugged file mode\n")); + + CreateFile(file2, fileName2, (EFileWrite | EFileSequential | EFileShareAny)); + r = TheFs.ControlIo(gDriveNum, EControlIOIsFileSequential, fileName2Pkg, fileModePkg); + test_KErrNone(r); + test_Equal(ENormalFileMode, fileMode); + + + file1.Close(); + file2.Close(); + DeleteFileAndDir(fileName2); + } + + + +void CallTestsL() +/* + * Start point of T_NONRUGGED + */ + { +#ifndef _DEBUG + test.Printf(_L("T_NONRUGGED skipped. To run only on debug builds.\n")); + return; +#else + + TInt r = TheFs.CharToDrive(gDriveToTest, gDriveNum); + test_KErrNone(r); + + // Currently only FAT file system supports Rugged drive + if (!Is_Fat(TheFs, gDriveNum)) + { + test.Printf(_L("T_NONRUGGED skipped. Requires FAT filesystem to run.\n")); + return; + } + +// Use this to set filesystem to Rugged if it is not set as such +#if(0) + { + // Ensure that the FAT filesystem is Rugged + TUint8 ruggedVal = 0; + TPtr8 ruggedPkg(&ruggedVal, 1, 1); + r = TheFs.ControlIo(gDriveNum, EControlIOIsRuggedFSys, ruggedPkg); + test_KErrNone(r); + if (!ruggedVal) + { + r = TheFs.ControlIo(gDriveNumber, KControlIoRuggedOn); + test_KErrNone(r); + } + } +#endif + + // Test to run only on a rugged FAT drive + TUint8 ruggedVal = 0; + TPtr8 ruggedPkg(&ruggedVal, 1, 1); + r = TheFs.ControlIo(gDriveNum, EControlIOIsRuggedFSys, ruggedPkg); + test_KErrNone(r); + if (!ruggedVal) + { + test.Printf(_L("T_NONRUGGED skipped. Requires Rugged FAT to run.\n")); + return; + } + + test.Start(_L("T_NONRUGGED Test Start")); + + // Run tests + SingleClientTest(); + MultipleClientsTest(); + +// Use this to unset filesystem to non-Rugged if it has been set above +#if(0) + // Set filesystem back to non-Rugged + if (!ruggedVal) + { + r = TheFs.ControlIo(gDriveNumber, KControlIoRuggedOff); + test_KErrNone(r); + } +#endif + + test.End(); + test.Close(); +#endif + }