diff -r 000000000000 -r 5752a19fdefe imagingtestenv/imagingtestfwunittest/src/tsu_mmtsth03/TSU_MmTsth03.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/imagingtestenv/imagingtestfwunittest/src/tsu_mmtsth03/TSU_MmTsth03.cpp Wed Aug 25 12:29:52 2010 +0300 @@ -0,0 +1,382 @@ +// 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 + +// Test system includes +#include + +// 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 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 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 testTDesC8Str = _L8("Test TDesC8 String"); + iFileName->Copy(testTDesC8Str); + // convert testTDesC8Str for comparison purposes + TBuf16 testCompTDesC8Str = _L16("Test TDesC8 String"); + if(testCompTDesC8Str != iFileName->FileName()) + { + ERR_PRINTF1(_L("CFileName::Copy(const TDesC8&) failed")); + return iTestStepResult = EFail; + } + + // test against TDesC16 + TBufC16 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 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 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 + + }