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

	}