/*
* Copyright (c) 2006 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: test case
*
*/
#include <w32std.h>
#include <coecntrl.h>
#include <eikenv.h>
#include <apmstd.h>
#include <PathInfo.h>
#include <apgcli.h>
#include <apmrec.h>
#include "bctestdocandinitcase.h"
#include "bctestdocandinitcontainer.h"
#include "bctestdocandinit.hrh"
// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// Symbian 2nd static Constructor
// ---------------------------------------------------------------------------
//
CBCTestDocAndInitCase* CBCTestDocAndInitCase::NewL(
CBCTestDocAndInitContainer* aContainer )
{
CBCTestDocAndInitCase* self = new( ELeave ) CBCTestDocAndInitCase(
aContainer );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// ---------------------------------------------------------------------------
// C++ default constructor
// ---------------------------------------------------------------------------
//
CBCTestDocAndInitCase::CBCTestDocAndInitCase(
CBCTestDocAndInitContainer* aContainer )
: iContainer( aContainer )
{
}
// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CBCTestDocAndInitCase::~CBCTestDocAndInitCase()
{
}
// ---------------------------------------------------------------------------
// Symbian 2nd Constructor
// ---------------------------------------------------------------------------
//
void CBCTestDocAndInitCase::ConstructL()
{
BuildScriptL();
}
// ---------------------------------------------------------------------------
// CBCTestDocAndInitCase::BuildScriptL
// ---------------------------------------------------------------------------
//
void CBCTestDocAndInitCase::BuildScriptL()
{
TCFDDriveStatus status = DriveStatus( EDriveE );
if (status != EDriveNotReady)
{
// Have E drive
AddTestL( DELAY( 10 ),
LeftCBA, Down, LeftCBA, DELAY( 10 ),
LeftCBA, LeftCBA, DELAY( 10 ),
LeftCBA, DELAY( 10 ),
LeftCBA, DELAY( 10 ),
LeftCBA, DELAY( 10 ),
LeftCBA, TEND );
}
else
{
// Not have E drive
AddTestL( DELAY( 10 ),
LeftCBA, Down, LeftCBA, DELAY( 10 ),
LeftCBA, LeftCBA, DELAY( 20 ),
LeftCBA, TEND );
}
}
// ---------------------------------------------------------------------------
// CBCTestDocAndInitCase::DriveStatus
// ---------------------------------------------------------------------------
//
TCFDDriveStatus CBCTestDocAndInitCase::DriveStatus( const TDriveNumber aDriveNumber )
{
RFs& fs = CCoeEnv::Static()->FsSession();
_LIT( KFat, "Fat" );
// Check if the drive is already mounted
TFullName fsName;
TInt error( fs.FileSystemName( fsName, aDriveNumber ) );
if( error )
{
return EDriveNotReady;
}
// check if MMC already mounted
if( fsName.Length() == 0 )
{
// MMC drive isnt mounted at present, so try it now....
error = fs.MountFileSystem( KFat, aDriveNumber );
// If it's a locked MMC and the password is already known it'll be
// unlocked automatically when it's mounted., otherwise the mount will
// return with KErrLocked.....
switch( error )
{
case KErrNone:
{
// OK to continue...
break;
}
case KErrLocked:
{
return EDriveLocked;
}
default:
{
return EDriveNotReady;
}
}
}
TDriveInfo driveInfo;
error = fs.Drive( driveInfo, aDriveNumber );
if( error )
{
return EDriveNotReady;
}
// MMC is in slot
if( driveInfo.iMediaAtt & KMediaAttLocked )
{
return EDriveLocked;
}
TVolumeInfo volumeInfo;
error = fs.Volume( volumeInfo, aDriveNumber );
if( error )
{
return EDriveNotReady;
}
return EDriveOK;
}
// ---------------------------------------------------------------------------
// CBCTestDocAndInitCase::RunL
// ---------------------------------------------------------------------------
//
void CBCTestDocAndInitCase::RunL( TInt aCmd )
{
if ( aCmd < EBCTestCmdDoc || aCmd > EBCTestCmdInit )
{
return;
}
switch ( aCmd )
{
case EBCTestCmdDoc:
TestDocument1L();
TestDocument2L();
break;
case EBCTestCmdInit:
TestInitializationL();
break;
default:
break;
}
}
// ---------------------------------------------------------------------------
// CBCTestDocAndInitCase::TestInitialization
// ---------------------------------------------------------------------------
//
void CBCTestDocAndInitCase::TestInitializationL()
{
TestAppUiFactoryL();
TestCoCtlLibraryL();
TestCtlLibraryL();
}
// ---------------------------------------------------------------------------
// CBCTestDocAndInitCase::TestAppUiFactory (Test class CEikAppUiFactory)
// ---------------------------------------------------------------------------
//
void CBCTestDocAndInitCase::TestAppUiFactoryL()
{
CEikAppUiFactory* factory = new( ELeave ) CEikAppUiFactory();
CleanupStack::PushL( factory );
_LIT( KCEikAppUiFactory, "CEikAppUiFactory::CEikAppUiFactory() invoked" );
AssertNotNullL( factory, KCEikAppUiFactory );
factory->TouchPane();
_LIT( KTouchPane , "CEikAppUiFactory::TouchPane() invoked" );
AssertTrueL( ETrue, KTouchPane );
factory->CurrentPopupToolbar();
_LIT( KCurrentPopupToolbar,
"CEikAppUiFactory::CurrentPopupToolbar() invoked" );
AssertTrueL( ETrue, KCurrentPopupToolbar );
CAknToolbar* popup = factory->PopupToolbar();
_LIT( KPopupToolbar, "CEikAppUiFactory::PopupToolbar() invoked" );
AssertTrueL( ETrue, KPopupToolbar );
factory->SetViewPopupToolbar( popup );
_LIT( KSetViewPopupToolbar,
"CEikAppUiFactory::SetViewPopupToolbar() invoked" );
AssertTrueL( ETrue, KSetViewPopupToolbar );
CleanupStack::PopAndDestroy( factory );
}
// ---------------------------------------------------------------------------
// CBCTestDocAndInitCase::TestCoCtlLibrary (Test class CEikCoCtlLibrary)
// ---------------------------------------------------------------------------
//
void CBCTestDocAndInitCase::TestCoCtlLibraryL()
{
CEikCoCtlLibrary::ButtonGroupFactory();
_LIT( KButtonGroupFactory ,
"CEikCoCtlLibrary::ButtonGroupFactory() invoked" );
AssertTrueL( ETrue, KButtonGroupFactory );
CEikCoCtlLibrary::ControlFactory();
_LIT( KControlFactory , "CEikCoCtlLibrary::ControlFactory() invoked" );
AssertTrueL( ETrue, KControlFactory );
CEikCoCtlLibrary::ResourceFile();
_LIT( KResourceFile , "CEikCoCtlLibrary::ResourceFile() invoked" );
AssertTrueL( ETrue, KResourceFile );
}
// ---------------------------------------------------------------------------
// CBCTestDocAndInitCase::TestCtlLibrary (Test class CEikCtlLibrary)
// ---------------------------------------------------------------------------
//
void CBCTestDocAndInitCase::TestCtlLibraryL()
{
CEikCtlLibrary::ResourceFile();
_LIT( KResourceFile , "CEikCtlLibrary::ResourceFile() invoked" );
AssertTrueL( ETrue, KResourceFile );
CEikCtlLibrary::ControlFactory();
_LIT( KControlFactory , "CEikCtlLibrary::ControlFactory() invoked" );
AssertTrueL( ETrue, KControlFactory );
CEikCtlLibrary::InitializeL();
_LIT( KInitializeL , "CEikCtlLibrary::InitializeL() invoked" );
AssertTrueL( ETrue, KInitializeL );
CEikCtlLibrary::ButtonGroupFactory();
_LIT( KButtonGroupFactory ,
"CEikCtlLibrary::ButtonGroupFactory() invoked" );
AssertTrueL( ETrue, KButtonGroupFactory );
}
// ---------------------------------------------------------------------------
// CBCTestDocAndInitCase::TestDocument1(Test class CDocumentHandler)
// ---------------------------------------------------------------------------
//
void CBCTestDocAndInitCase::TestDocument1L()
{
CDocumentHandler *docHandler = CDocumentHandler::NewL();
_LIT( KNewL1 , "CDocumentHandler::NewL() invoked" );
AssertNotNullL( docHandler, KNewL1 );
docHandler->SetExitObserver( this );
_LIT( KSetExitObserver ,
"CDocumentHandler::SetExitObserver(MAknServerAppExitObserver*) invoked" );
AssertTrueL( ETrue, KSetExitObserver );
docHandler->InParamListL();
_LIT( KInParamListL , "CDocumentHandler::InParamListL() invoked" );
AssertTrueL( ETrue, KInParamListL );
TDataType dataType;
_LIT( KEmbeddedFileName, "C:\\data\\Others\\DocHandleEmbedded.txt" );
RFs& fs = CEikonEnv::Static()->FsSession();
RFile embeddedFile;
if( embeddedFile.Open( fs, KEmbeddedFileName,
EFileWrite | EFileShareAny ) != KErrNone )
{
embeddedFile.Create( fs, KEmbeddedFileName,
EFileWrite | EFileShareAny );
}
_LIT8( KContent, "Content Text" );
embeddedFile.Write( KContent );
TInt error;
error = docHandler->OpenFileEmbeddedL( KEmbeddedFileName, dataType );
_LIT( KOpenFileEmbeddedL1 ,
"CDocumentHandler::OpenFileEmbeddedL(const TDesC&,TDataType&) invoked" );
AssertIntL( KErrNone, error, KOpenFileEmbeddedL1 );
error = docHandler->OpenFileEmbeddedL( embeddedFile, dataType );
_LIT( KOpenFileEmbeddedL2 ,
"CDocumentHandler::OpenFileEmbeddedL(RFile&,TDataType&) invoked" );
AssertIntL( KErrNone, error, KOpenFileEmbeddedL2 );
TBuf<32> fileName;
docHandler->CheckFileNameExtension( fileName, dataType );
_LIT( KCheckFileNameExtension ,
"CDocumentHandler::CheckFileNameExtension(TDes&,TDataType&) invoked" );
AssertTrueL( ETrue, KCheckFileNameExtension );
TBool canOpen = docHandler->CanOpenL( dataType );
_LIT( KCanOpenL , "CDocumentHandler::CanOpenL(TDataType&) invoked" );
AssertTrueL( canOpen, KCanOpenL );
TBool canHandle = docHandler->CanHandleL( dataType );
_LIT( KCanHandleL , "CDocumentHandler::CanHandleL(TDataType&) invoked" );
AssertTrueL( canHandle, KCanHandleL );
TBool canSave = docHandler->CanSaveL( dataType );
_LIT( KCanSaveL , "CDocumentHandler::CanSaveL(TDataType&) invoked" );
AssertTrueL( canSave, KCanSaveL );
docHandler->GetPath( fileName );
_LIT( KGetPath, "CDocumentHandler::GetPath(TDes&) invoked" );
AssertTrueL( ETrue, KGetPath );
RFile tempFile;
_LIT( KTempFileName, "C:\\data\\Others\\Temp.txt" );
fs.Delete( KTempFileName );
docHandler->SaveTempFileL( KContent, dataType, KTempFileName, tempFile );
_LIT( KSaveTempFileL, "CDocumentHandler::SaveTempFileL() invoked" );
AssertTrueL( ETrue, KSaveTempFileL );
tempFile.Close();
TUid uid;
docHandler->HandlerAppUid( uid );
_LIT( KHandlerAppUid, "CDocumentHandler::HandlerAppUid(TUid&) invoked" );
AssertTrueL( ETrue, KHandlerAppUid );
embeddedFile.Close();
docHandler->OutParamList();
_LIT( KOutParamList , "CDocumentHandler::OutParamList() invoked" );
AssertTrueL( ETrue, KOutParamList );
delete docHandler;
}
// ---------------------------------------------------------------------------
// CBCTestDocAndInitCase::TestDocument2 (Test class CDocumentHandler)
// ---------------------------------------------------------------------------
//
void CBCTestDocAndInitCase::TestDocument2L()
{
_LIT8( KMyMimeType, "text/vnd.bctest" );
_LIT( KOldFileName, "C:\\data\\Others\\DocHandleEmbedded.txt" );
_LIT( KOpenFileName, "C:\\data\\Others\\Open.txt" );
_LIT( KOtherPath, "C:\\data\\Others\\" );
_LIT( KNewFileName, "New.txt" );
_LIT( KUnNameFile, "Unnamed" );
TFileName path( KOtherPath );
TFileName tmppath( KOtherPath );
path.Append( KNewFileName );
tmppath.Append( KUnNameFile );
_LIT8( KContentText, "Content Text" );
TDataType dataType( KMyMimeType );
CEikProcess* proc = CEikonEnv::Static()->Process();
CDocumentHandler *doc = CDocumentHandler::NewL(proc);
CleanupStack::PushL( doc );
_LIT( KNewL2 , "CDocumentHandler::NewL(CEikProcess*) invoked" );
AssertNotNullL( doc, KNewL2 );
RFs& fs = CEikonEnv::Static()->FsSession();
RFile File1;
fs.Delete( path );
if ( File1.Open( fs, KOpenFileName, EFileWrite | EFileShareAny )
!= KErrNone )
{
File1.Create( fs, KOpenFileName, EFileWrite | EFileShareAny );
}
TInt move = doc->MoveL( KOldFileName, KNewFileName, dataType, 0 );
_LIT( KMoveL, "CDocumentHandler::MoveL() invoked" );
AssertIntL( KErrNone, move, KMoveL );
fs.Delete( tmppath );
TInt save = doc->SaveL(KContentText, dataType, 0 );
_LIT( KSaveL, "CDocumentHandler::SaveL() invoked" );
AssertIntL( KErrNone, save, KSaveL );
fs.Delete( path );
TInt copy = doc->CopyL( File1, KNewFileName, dataType, 0 );
_LIT( KCopyL1, "CDocumentHandler::CopyL() invoked" );
AssertIntL( KErrNone, copy, KCopyL1 );
File1.Close();
fs.Delete( path );
copy = doc->CopyL( KOpenFileName, KNewFileName, dataType, 0 );
_LIT( KCopyL2 ,
"CDocumentHandler::CopyL(TDesC8&,TDesC&,TDataType&,TUint) invoked" );
AssertIntL( KErrNone, copy, KCopyL2 );
TInt error = doc->SilentMoveL( KOpenFileName, KNewFileName,
PathInfo::PhoneMemoryRootPath(), dataType, 0 );
_LIT( KSilentMoveL, "CDocumentHandler::SilentMoveL() invoked" );
AssertIntL( KErrNone, error, KSilentMoveL );
CleanupStack::PopAndDestroy( doc );
_LIT( KUCDocumentHandler,
"CDocumentHandler::~CDocumentHandler() invoked" );
AssertTrueL( ETrue, KUCDocumentHandler );
}
// ---------------------------------------------------------------------------
// CBCTestDocAndInitCase::HandleServerAppExit (from MAknServerAppExitObserver)
// ---------------------------------------------------------------------------
//
void CBCTestDocAndInitCase::HandleServerAppExit( TInt /*aReason*/ )
{
}