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

 // This file contains the test steps for Unit Test Suite 03 : Filename.cpp

 // 

 //

 // EPOC includes

 #include <e32base.h>

 // Test system includes

 #include <testframework.h>

 // Specific includes for this test suite

 #include "TSU_MmTsthStep03.h"

 #include "TSU_MmTsthSuite03.h"

 // Specific includes for these test steps

 #include "TSU_MmTsth03.h"

 #include "TestFramework/Filename.h"

 // --------------------------------------------

 // Unit Test Suite 03 : Filename.cpp

 // Depends on : none

 // Tests :-

 // 1. Allocate and deallocate an object

 // 2. Test assignment overloads

 // 3. Test copy overloads

 // 4. Test locate

 // 5. Test slicing (Left)

 // 11. Test data scope

 // ---------------------

 // RTestMmTsthU0301

 RTestMmTsthU0301* RTestMmTsthU0301::NewL()

 	{

 	RTestMmTsthU0301* self = new(ELeave) RTestMmTsthU0301;

 	return self;

 	}

 // Each test step initialises its own name.

 RTestMmTsthU0301::RTestMmTsthU0301()

 	{

 	iTestStepName = _L("MM-TSTH-U-0301");

 	}

 // preamble

 TVerdict RTestMmTsthU0301::OpenL()

 	{

 	// stub - to avoid calling RTestStep_MM_TSTH_U_03::OpenL() which

 	// initialises iFileName

 	return iTestStepResult = EPass;

 	}

 // postamble

 void RTestMmTsthU0301::Close()

 	{

 	}

 // do the test step.

 TVerdict RTestMmTsthU0301::DoTestStepL()

 	{

 	// NB this test is the test for NewL() therefore it uses

 	// a stubbed preamble / postamble

 	INFO_PRINTF1(_L("Create a CFileName"));

 	TVerdict currentVerdict = EPass;

 	// create a CFileName with NewL

 	CFileName* theFileName = NULL;

 	TRAPD(err, theFileName = CFileName::NewL());

 	if(err != KErrNone)

 		{

 		ERR_PRINTF2(_L("CFileName::NewL left with code %d"), err);

 		return iTestStepResult = EFail;

 		}

 	INFO_PRINTF1(_L("CFileName::NewL succeeded"));

 	delete theFileName;

 	// create a CFileName with NewLC

 	CFileName* theLCFileName = NULL;

 	TRAPD(err2, theLCFileName = CFileName::NewLC();

 				CleanupStack::Pop(theLCFileName) );

 	if(err2 != KErrNone)

 		{

 		ERR_PRINTF2(_L("CFileName::NewLC left with code %d"), err2);

 		return iTestStepResult = EFail;

 		}

 	INFO_PRINTF1(_L("CFileName::NewLC succeeded"));

 	delete theLCFileName;

 	return iTestStepResult = currentVerdict; // should be EPass if we've got here

 	}

 // ------------------------

 // RTestMmTsthU0302

 RTestMmTsthU0302* RTestMmTsthU0302::NewL()

 	{

 	RTestMmTsthU0302* self = new(ELeave) RTestMmTsthU0302;

 	return self;

 	}

 // Each test step initialises its own name.

 RTestMmTsthU0302::RTestMmTsthU0302()

 	{

 	iTestStepName = _L("MM-TSTH-U-0302");

 	}

 // do the test step.

 TVerdict RTestMmTsthU0302::DoTestStepL()

 	{

 	const TInt KTestBufSize = 48;	// allocate enough space for test strings

 	INFO_PRINTF1(_L("Test CFileName assign overloads"));

 	TVerdict currentVerdict = EPass;

 	// test against TPtrC

 	TPtrC testTPtrCStr = _L("Test TPtrC String");

 	*iFileName = testTPtrCStr;

 	if(testTPtrCStr != iFileName->FileName())

 		{

 		ERR_PRINTF1(_L("CFileName::operator=(const TPtrC&) failed"));

 		return iTestStepResult = EFail;

 		}

 	// test against TDesC

 	TBufC<KTestBufSize> testTDesCStr = _L("Test TDesC String");

 	*iFileName = testTDesCStr;

 	if(testTDesCStr != iFileName->FileName())

 		{

 		ERR_PRINTF1(_L("CFileName::operator=(const TDesC&) failed"));

 		return iTestStepResult = EFail;

 		}

 	// test against TFileName

 	TFileName testTFileNameStr = _L("Test TFileName String");

 	*iFileName = testTFileNameStr;

 	if(testTFileNameStr != iFileName->FileName())

 		{

 		ERR_PRINTF1(_L("CFileName::operator=(const TFileName&) failed"));

 		return iTestStepResult = EFail;

 		}

 	// test against TText*

 	const TText* testTTextStr = _S("Test TText String\0");

 	*iFileName = testTTextStr;

 	// convert testTTextStr for comparison purposes

 	TBuf<KTestBufSize> testCompTTextStr(testTTextStr);

 	if(testCompTTextStr != iFileName->FileName())

 		{

 		ERR_PRINTF1(_L("CFileName::operator=(const TText*) failed"));

 		return iTestStepResult = EFail;

 		}

 	// test against self

 	CFileName* testCFileName = CFileName::NewL();

 	*testCFileName = _L("Test CFileName String");

 	*iFileName = *testCFileName;

 	if(testCFileName->FileName() != iFileName->FileName())

 		{

 		ERR_PRINTF1(_L("CFileName::operator=(const CFileName&) failed"));

 		delete testCFileName;

 		return iTestStepResult = EFail;

 		}

 	delete testCFileName;

 	return iTestStepResult = currentVerdict; // should be EPass if we've got here

 	}

 // ------------------------

 // RTestMmTsthU0303

 RTestMmTsthU0303* RTestMmTsthU0303::NewL()

 	{

 	RTestMmTsthU0303* self = new(ELeave) RTestMmTsthU0303;

 	return self;

 	}

 // Each test step initialises its own name.

 RTestMmTsthU0303::RTestMmTsthU0303()

 	{

 	iTestStepName = _L("MM-TSTH-U-0303");

 	}

 // do the test step.

 TVerdict RTestMmTsthU0303::DoTestStepL()

 	{

 	const TInt KTestBufSize = 48;	// allocate enough space for test strings

 	INFO_PRINTF1(_L("Test CFileName::Copy"));

 	TVerdict currentVerdict = EPass;

 	// test against TDesC8

 	TBufC8<KTestBufSize> testTDesC8Str = _L8("Test TDesC8 String");

 	iFileName->Copy(testTDesC8Str);

 	// convert testTDesC8Str for comparison purposes

 	TBuf16<KTestBufSize> testCompTDesC8Str = _L16("Test TDesC8 String");

 	if(testCompTDesC8Str != iFileName->FileName())

 		{

 		ERR_PRINTF1(_L("CFileName::Copy(const TDesC8&) failed"));

 		return iTestStepResult = EFail;

 		}

 	// test against TDesC16

 	TBufC16<KTestBufSize> testTDesC16Str = _L16("Test TDesC16 String");

 	iFileName->Copy(testTDesC16Str);

 	if(testTDesC16Str != iFileName->FileName())

 		{

 		ERR_PRINTF1(_L("CFileName::Copy(const TDesC16&) failed"));

 		return iTestStepResult = EFail;

 		}

 	// test against TUint16* with length

 	const TUint16* testTUint16Str = _S16("Test TUint16 String");

 	// convert testTUint16Str for comparison purposes

 	TBuf16<KTestBufSize> testCompTUint16Str(testTUint16Str);

 	iFileName->Copy(testTUint16Str, testCompTUint16Str.Length());

 	const TDesC& iFileNameLeft = iFileName->FileName().Left(testCompTUint16Str.Length());

 	if(testCompTUint16Str != iFileNameLeft)

 		{

 		ERR_PRINTF1(_L("CFileName::Copy(const TUint16*, int) failed"));

 		return iTestStepResult = EFail;

 		}

 	// test against TUint16* zero terminated

 	const TUint16* testTUint16ZStr = _S16("Test TUint16Z String\0");

 	iFileName->Copy(testTUint16ZStr);

 	// convert testTUint16Str for comparison purposes

 	TBuf16<KTestBufSize> testCompTUint16ZStr(testTUint16ZStr);

 	if(testCompTUint16ZStr != iFileName->FileName())

 		{

 		ERR_PRINTF1(_L("CFileName::Copy(const TUint16*) failed"));

 		return iTestStepResult = EFail;

 		}

 	return iTestStepResult = currentVerdict; // should be EPass if we've got here

 	}

 // ------------------------

 // RTestMmTsthU0304

 RTestMmTsthU0304* RTestMmTsthU0304::NewL()

 	{

 	RTestMmTsthU0304* self = new(ELeave) RTestMmTsthU0304;

 	return self;

 	}

 // Each test step initialises its own name.

 RTestMmTsthU0304::RTestMmTsthU0304()

 	{

 	iTestStepName = _L("MM-TSTH-U-0304");

 	}

 // Do the test step.

 TVerdict RTestMmTsthU0304::DoTestStepL()

 	{

 	INFO_PRINTF1(_L("Test CFileName::Locate"));

 	TVerdict currentVerdict = EPass;

 	// test is inconclusive if the assignment fails

 	TPtrC testLocateStr = _L("ABCDEFG");

 	*iFileName = testLocateStr;

 	if(testLocateStr != iFileName->FileName())

 		{

 		ERR_PRINTF1(_L("CFileName::operator=(const TPtrC&) failed in Locate Test"));

 		return iTestStepResult = EInconclusive;

 		}

 	TInt rc = iFileName->Locate('C');

 	if(rc != 2)

 		{

 		ERR_PRINTF1(_L("CFileName::Locate() failed"));

 		return iTestStepResult = EFail;

 		}

 	rc = iFileName->Locate('Z');

 	if(rc != KErrNotFound)

 		{

 		ERR_PRINTF1(_L("CFileName::Locate() failed"));

 		return iTestStepResult = EFail;

 		}

 	return iTestStepResult = currentVerdict; // should be EPass if we've got here

 	}

 // ------------------------

 // RTestMmTsthU0305

 RTestMmTsthU0305* RTestMmTsthU0305::NewL()

 	{

 	RTestMmTsthU0305* self = new(ELeave) RTestMmTsthU0305;

 	return self;

 	}

 // Each test step initialises its own name.

 RTestMmTsthU0305::RTestMmTsthU0305()

 	{

 	iTestStepName = _L("MM-TSTH-U-0305");

 	}

 // Do the test step.

 TVerdict RTestMmTsthU0305::DoTestStepL()

 	{

 	INFO_PRINTF1(_L("Test CFileName::Left"));

 	TVerdict currentVerdict = EPass;

 	// test is inconclusive if the assignment fails

 	TPtrC testLocateStr = _L("ABCDEFG");

 	*iFileName = testLocateStr;

 	if(testLocateStr != iFileName->FileName())

 		{

 		ERR_PRINTF1(_L("CFileName::operator=(const TPtrC&) failed in Locate Test"));

 		return iTestStepResult = EInconclusive;

 		}

 	const TFileName& iFileNameLeft = iFileName->Left(3);

 	TPtrC testLeftStr = _L("ABC");

 	if(testLeftStr != iFileNameLeft)

 		{

 		ERR_PRINTF1(_L("CFileName::Left() failed"));

 		return iTestStepResult = EFail;

 		}

 	return iTestStepResult = currentVerdict; // should be EPass if we've got here

 	}

 // ------------------------

 // RTestMmTsthU0311

 RTestMmTsthU0311* RTestMmTsthU0311::NewL()

 	{

 	RTestMmTsthU0311* self = new(ELeave) RTestMmTsthU0311;

 	return self;

 	}

 // Each test step initialises its own name.

 RTestMmTsthU0311::RTestMmTsthU0311()

 	{

 	iTestStepName = _L("MM-TSTH-U-0311");

 	}

 // Do the test step.

 TVerdict RTestMmTsthU0311::DoTestStepL()

 	{

 	const TInt KTestBufSize = 48;	// allocate enough space for test strings

 	INFO_PRINTF1(_L("Test CFileName memory scope"));

 	TVerdict currentVerdict = EPass;

 	// send original copied string out of scope, to prove that CFileName

 	// is using its own data space

 	TPtr16 testDynTDesCStr(REINTERPRET_CAST(TUint16*,User::AllocLC(KTestBufSize*2)), 0, KTestBufSize);

 	testDynTDesCStr = _L("Test TDesC String");

 	*iFileName = testDynTDesCStr;

 	CleanupStack::PopAndDestroy(); // testDynTDesCStr

 	// if iFileName->FileName() is out of scope, this will panic with USER 7. If it doesn't, we've passed

 	TPtrC resStr = iFileName->FileName();

 	INFO_PRINTF2(_L("CFileName::FileName() is '%S'"), &resStr);

 	return iTestStepResult = currentVerdict; // should be EPass if we've got here

 	}