// Copyright (c) 2005-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:
//
#include "caltestlib.h"
#include <calentry.h>
#include <calentryview.h>
#include <calalarm.h>
#include <calattachment.h>
#include <calattachmentmanager.h>
#include <calcategory.h>
#include <calcategorymanager.h>
#include <calsession.h>
#include <calinstance.h>
#include <caliterator.h>
#include <calinstanceview.h>
#include <calrrule.h>
#include <e32test.h>
#include <s32file.h>
// Uncomment this line to test manually
// #define TEST_MANUALLY
static RTest test(_L("tcal_removable_media"));
_LIT(KRemovableMediaTestFile, "removable_media");
class CCalRemovableMediaTest : public CBase, public MCalProgressCallBack
{
public:
static CCalRemovableMediaTest* NewLC();
~CCalRemovableMediaTest();
void DoTestsL();
// from MCalProgressCallBack
void Progress(TInt aPercentageCompleted);
void Completed(TInt aError);
TBool NotifyProgress();
private:
CCalRemovableMediaTest();
void ConstructL();
void NextStepL(TInt aStep);
void InitialiseFileL();
void StoreEntriesL(TBool aTestStoreL);
void UpdateEntriesL();
void DeleteEntriesByUidL();
void DeleteEntriesByLocalUidL();
void DeleteEntriesAsynchronouslyByTimeL();
void DeleteInstanceL();
void AddCategoryL(TBool aTestAdd);
void DeleteCategoryL();
void GetNumEntriesL();
void CheckUpdateL();
void CheckDeleteAsynchronouslyByTime();
void CheckNumEntriesL();
void CheckNumAttachmentsL();
void TestAfterMediaRemovedL();
void CheckNumCategoriesL();
void CheckDeleteCategory();
void CheckDeleteInstanceL();
void AddSecondCategoryL();
void AddAttachmentL(TBool aTesting);
void UpdateAttachmentL();
void DeleteAttachmentL();
void CheckDeleteAttachmentL();
void ChangeAttachmentDriveL();
TInt AttachmentFileCountL() const;
void SetupTestLibL();
void ClearTestLib();
void FindEntriesWithTextL(RPointerArray<CCalInstance>& aInstances, const TDesC& aText);
void RemoveMedia();
void ReplaceMedia();
TBool MediaRemoved() const;
private:
enum
{
ETestStore,
ECheckStore,
ETestUpdate,
ECheckUpdate,
ETestDeleteByTime,
ECheckDeleteByTime,
ETestDeleteByLocalUid,
ECheckDeleteByLocalUid,
ETestDeleteByUid,
ECheckDeleteByUid,
ETestAddCategory,
ECheckAddCategory,
ETestAddSecondCategory,
ECheckAddSecondCategory,
ETestDeleteCategory,
ECheckDeleteCategory,
ETestDeleteInstance,
ECheckDeleteInstance,
ETestAddAttachment,
ECheckAddAttachment,
ETestUpdateAttachment,
ECheckUpdateAttachment,
ETestDeleteAttachment,
ECheckDeleteAttachment,
EChangeAttachmentDrive,
ETestAfterMediaRemoved,
EFinishedTests,
// edit this to change where the test starts
EFirstStep = ETestStore,
};
CCalTestLibrary* iTestLib;
CCalCategoryManager* iCatMan;
CCalAttachmentManager* iAttMan;
TBuf<32> iCalendarName;
TInt iError;
TInt iNumEntries;
TInt iNumAttachments;
TBool iMediaRemoved;
};
void CCalRemovableMediaTest::Progress(TInt )
{
}
void CCalRemovableMediaTest::Completed(TInt aError)
{
iError = aError;
test.Printf(_L("Completed with error %d \n"), aError);
CActiveScheduler::Stop();
}
TBool CCalRemovableMediaTest::NotifyProgress()
{
return EFalse;
}
void CCalRemovableMediaTest::RemoveMedia()
{
#ifdef TEST_MANUALLY
test.Printf(_L("Remove the media and press any key.\n")); test.Getch();
#else
iTestLib->FileSession().SetErrorCondition(KErrNotReady, 0);
User::After(500000);
#endif
iMediaRemoved = ETrue;
}
void CCalRemovableMediaTest::ReplaceMedia()
{
#ifdef TEST_MANUALLY
test.Printf(_L("Reinsert the media and press any key...\n")); test.Getch();
#else
User::After(500000);
#endif
iMediaRemoved = EFalse;
}
TBool CCalRemovableMediaTest::MediaRemoved() const
{
return iMediaRemoved;
}
void CCalRemovableMediaTest::NextStepL(TInt aStep)
{
if (MediaRemoved())
{
ReplaceMedia();
}
TRAPD(err, SetupTestLibL());
if (err != KErrNone)
{
test.Printf(_L("Failed to re-open calendar file, error %d\n"), err);
test(0);
}
switch (aStep)
{
case ETestStore:
StoreEntriesL(ETrue);
break;
case ECheckStore:
CheckNumEntriesL();
break;
case ETestUpdate:
UpdateEntriesL();
break;
case ECheckUpdate:
CheckUpdateL();
CheckNumEntriesL();
break;
case ETestDeleteByTime:
DeleteEntriesAsynchronouslyByTimeL();
break;
case ECheckDeleteByTime:
CheckDeleteAsynchronouslyByTime();
CheckNumEntriesL();
break;
case ETestDeleteByLocalUid:
DeleteEntriesByLocalUidL();
break;
case ECheckDeleteByLocalUid:
CheckNumEntriesL();
break;
case ETestDeleteByUid:
DeleteEntriesByUidL();
break;
case ECheckDeleteByUid:
CheckNumEntriesL();
break;
case ETestAddCategory:
AddCategoryL(ETrue);
break;
case ECheckAddCategory:
CheckNumCategoriesL();
break;
case ETestAddSecondCategory:
AddSecondCategoryL();
break;
case ECheckAddSecondCategory:
CheckNumCategoriesL();
break;
case ETestDeleteCategory:
DeleteCategoryL();
break;
case ECheckDeleteCategory:
CheckDeleteCategory();
CheckNumCategoriesL();
break;
case ETestDeleteInstance:
DeleteInstanceL();
break;
case ECheckDeleteInstance:
CheckDeleteInstanceL();
break;
case ETestAddAttachment:
AddAttachmentL(ETrue);
break;
case ECheckAddAttachment:
CheckNumAttachmentsL();
break;
case ETestUpdateAttachment:
UpdateAttachmentL();
break;
case ECheckUpdateAttachment:
CheckNumEntriesL();
CheckNumAttachmentsL();
break;
case ETestDeleteAttachment:
DeleteAttachmentL();
break;
case ECheckDeleteAttachment:
CheckDeleteAttachmentL();
break;
case EChangeAttachmentDrive:
ChangeAttachmentDriveL();
break;
case ETestAfterMediaRemoved:
TestAfterMediaRemovedL();
break;
}
ClearTestLib();
}
void CCalRemovableMediaTest::InitialiseFileL()
{
// ensure there are at least 10 entries in file
GetNumEntriesL();
if (iNumEntries < 10)
{
StoreEntriesL(EFalse);
GetNumEntriesL();
}
}
void CCalRemovableMediaTest::StoreEntriesL(TBool aTestStoreL)
{
if (aTestStoreL)
{
test.Next(_L("Test StoreL"));
}
const TInt KNumEntries = 10;
test.Printf(_L("Creating %d non-repeating entries \n"), KNumEntries);
TTime time;
time.HomeTime();
GetNumEntriesL();
test.Printf(_L("Number of entries before add is %d\n"), iNumEntries);
RPointerArray<CCalEntry> entryArray;
CleanupResetAndDestroyPushL(entryArray);
for (TInt i = 0; i < KNumEntries; ++i)
{
time -= TTimeIntervalDays(1);
TBuf8<64> buf;
iTestLib->RandomText8(buf);
CCalEntry::TType type = CCalEntry::EAppt;
if (i % 2 == 0)
{
type = CCalEntry::ETodo;
}
HBufC8* bufAlloc = buf.AllocLC();
CCalEntry* entry = iTestLib->CreateCalEntryL(type, bufAlloc);
CleanupStack::Pop(); // buf.AllocLC()
CleanupStack::PushL(entry);
iTestLib->SetEntryStartAndEndTimeL(entry, time, time);
entryArray.AppendL(entry);
CleanupStack::Pop(entry);
}
if (aTestStoreL)
{
RemoveMedia();
}
TInt success(0);
test.Printf(_L("Adding entries..."));
TRAPD(err, iTestLib->SynCGetEntryViewL().StoreL(entryArray, success));
test.Printf(_L("StoreL gave error %d, num successfully added=%d\n"), err, success);
if (aTestStoreL)
{
test(err == KErrNotReady);
test(success == 0);
}
else
{
User::LeaveIfError(err);
test(success == KNumEntries);
}
CleanupStack::PopAndDestroy(&entryArray);
}
void CCalRemovableMediaTest::FindEntriesWithTextL(RPointerArray<CCalInstance>& aInstances, const TDesC& aText)
{
CalCommon::TCalViewFilter filter = CalCommon::EIncludeAll | CalCommon::EIncludeRptsNextInstanceOnly;
TCalTime minTime;
minTime.SetTimeUtcL(TCalTime::MinTime());
TCalTime maxTime;
maxTime.SetTimeUtcL(TCalTime::MaxTime());
CalCommon::TCalTimeRange timeRange(minTime, maxTime);
CCalInstanceView::TCalSearchParams searchParams(aText, CalCommon::EFoldedTextSearch);
iTestLib->SynCGetInstanceViewL().FindInstanceL(aInstances, filter, timeRange, searchParams);
}
void CCalRemovableMediaTest::UpdateEntriesL()
{
test.Next(_L("Test UpdateL\n"));
InitialiseFileL();
test.Printf(_L("Updating %d entries \n"), iNumEntries);
RPointerArray<CCalInstance> instArray;
CleanupResetAndDestroyPushL(instArray);
FindEntriesWithTextL(instArray, KNullDesC);
RPointerArray<CCalEntry> entryArray;
CleanupClosePushL(entryArray);
for (TInt i = 0; i < instArray.Count(); ++i)
{
CCalEntry* entry = &instArray[i]->Entry();
entry->SetSummaryL(_L("updated summary"));
entryArray.AppendL(entry);
}
RemoveMedia();
TInt success(0);
test.Printf(_L("Updating entries..."));
TRAPD(err, iTestLib->SynCGetEntryViewL().UpdateL(entryArray, success));
test.Printf(_L("UpdateL gave error %d, num successfully updated=%d\n"), err, success);
test(err == KErrNotReady);
test(success == 0);
CleanupStack::PopAndDestroy(&entryArray); // Close()
CleanupStack::PopAndDestroy(&instArray); // ResetAndDestroy()
}
void CCalRemovableMediaTest::CheckUpdateL()
{
RPointerArray<CCalInstance> instArray;
CleanupResetAndDestroyPushL(instArray);
// check that no entries were updated
test.Printf(_L("Checking no entries were updated..."));
FindEntriesWithTextL(instArray, _L("updated summary"));
test.Printf(_L("%d entries were updated\n"), instArray.Count());
test(instArray.Count() == 0);
CleanupStack::PopAndDestroy(&instArray); // ResetAndDestroy
}
void CCalRemovableMediaTest::GetNumEntriesL()
{
RArray<TCalLocalUid> localUids;
CleanupClosePushL(localUids);
TCalTime minTime;
minTime.SetTimeUtcL(TCalTime::MinTime());
iTestLib->SynCGetEntryViewL().GetIdsModifiedSinceDateL(minTime, localUids);
iNumEntries = localUids.Count();
CleanupStack::PopAndDestroy(&localUids); // Close()
iNumAttachments = AttachmentFileCountL();
}
TInt CCalRemovableMediaTest::AttachmentFileCountL() const
{
CCalAttachmentIterator* attachments = iAttMan->FetchAttachmentsL(CCalAttachmentManager::ESortBySizeLargestFirst);
TInt count = attachments->Count();
delete attachments;
return count;
}
void CCalRemovableMediaTest::CheckNumEntriesL()
{
RArray<TCalLocalUid> localUids;
CleanupClosePushL(localUids);
TCalTime minTime;
minTime.SetTimeUtcL(TCalTime::MinTime());
test.Printf(_L("Checking number of entries: expected=%d..."), iNumEntries);
iTestLib->SynCGetEntryViewL().GetIdsModifiedSinceDateL(minTime, localUids);
test.Printf(_L("Number of entries found=%d\n"), localUids.Count());
test(iNumEntries == localUids.Count());
CleanupStack::PopAndDestroy(&localUids); // Close()
}
void CCalRemovableMediaTest::CheckNumAttachmentsL()
{
if (iNumAttachments > 0)
{
test.Printf(_L("Checking number of attachments: expected=%d...Number of entries found=%d\n"), iNumAttachments, AttachmentFileCountL());
test(iNumAttachments == AttachmentFileCountL());
}
}
void CCalRemovableMediaTest::DeleteEntriesByLocalUidL()
{
test.Next(_L("Test DeleteL by local UID\n"));
InitialiseFileL();
test.Printf(_L("Deleting all entries by local uid \n"));
test.Printf(_L("Number of entries before delete is %d\n"), iNumEntries);
RArray<TCalLocalUid> localUids;
CleanupClosePushL(localUids);
TCalTime minTime;
minTime.SetTimeUtcL(TCalTime::MinTime());
iTestLib->SynCGetEntryViewL().GetIdsModifiedSinceDateL(minTime, localUids);
test(localUids.Count() == iNumEntries); // check all local uids found
RemoveMedia();
TInt success = 0;
test.Printf(_L("Doing delete..."));
TRAPD(err, iTestLib->SynCGetEntryViewL().DeleteL(localUids, success));
test.Printf(_L("DeleteL gave err %d, num successfully deleted=%d\n"), err, success);
test(err == KErrNotReady);
test(success == 0);
CleanupStack::PopAndDestroy(&localUids); // Close()
}
void CCalRemovableMediaTest::DeleteEntriesByUidL()
{
test.Next(_L("Test DeleteL by GUID\n"));
InitialiseFileL();
RPointerArray<CCalEntry> entries;
CleanupResetAndDestroyPushL(entries);
CDesC8Array* uidArray = new (ELeave) CDesC8ArraySeg(8);
CleanupStack::PushL(uidArray);
CCalIter& iter = iTestLib->GetIterL();
TPtrC8 uid = iter.FirstL();
while (uid.Length() > 0)
{
uidArray->AppendL(uid);
uid.Set(iter.NextL());
}
test(iNumEntries == uidArray->Count());
test.Printf(_L("Found %d entries before delete\n"), iNumEntries);
RemoveMedia();
test.Printf(_L("Deleting entries..."));
TRAPD(err, iTestLib->SynCGetEntryViewL().DeleteL(*uidArray));
test(err == KErrNotReady);
test.Printf(_L("DeleteL gave error %d...\n"), err);
CleanupStack::PopAndDestroy(uidArray);
CleanupStack::PopAndDestroy(&entries);
}
void CCalRemovableMediaTest::DeleteEntriesAsynchronouslyByTimeL()
{
test.Next(_L("Test DeleteL by time\n"));
InitialiseFileL();
TCalTime minTime;
minTime.SetTimeUtcL(TCalTime::MinTime());
TCalTime maxTime;
maxTime.SetTimeUtcL(TCalTime::MaxTime());
CalCommon::TCalTimeRange timeRange(minTime, maxTime);
CalCommon::TCalViewFilter filter = CalCommon::EIncludeAll;
RemoveMedia();
test.Printf(_L("Deleting entries...\n"));
TRAPD(err, iTestLib->SynCGetEntryViewL().DeleteL(timeRange, filter, *this));
test.Printf(_L("DeleteL gave error %d...\n"), err);
test(err == KErrNone);
CActiveScheduler::Start();
}
void CCalRemovableMediaTest::CheckDeleteAsynchronouslyByTime()
{
test(iError == KErrNotReady);
}
void CCalRemovableMediaTest::AddCategoryL(TBool aTestAdd)
{
if (aTestAdd)
{
test.Next(_L("Test AddCategoryL\n"));
}
iNumEntries = iCatMan->CategoryCountL();
test.Printf(_L("Adding a category...\n"));
TBuf<24> categoryName;
TTime now;
now.UniversalTime();
categoryName.AppendNum(now.Int64());
CCalCategory* category = CCalCategory::NewL(categoryName);
CleanupStack::PushL(category);
if (aTestAdd)
{
RemoveMedia();
}
TRAPD(err, iCatMan->AddCategoryL(*category));
CleanupStack::PopAndDestroy(category);
if (aTestAdd)
{
test.Printf(_L("Adding category gave error %d...\n"), err);
test(err == KErrNotReady);
}
else
{
test(err == KErrNone);
}
}
void CCalRemovableMediaTest::AddSecondCategoryL()
{
test.Next(_L("Test AddSecondCategoryL\n"));
AddCategoryL(EFalse);
iNumEntries = iCatMan->CategoryCountL();
test.Printf(_L("Adding a second category...\n"));
TBuf<24> categoryName;
TTime now;
now.UniversalTime();
categoryName.AppendNum(now.Int64()+1);
CCalCategory* category = CCalCategory::NewL(categoryName);
CleanupStack::PushL(category);
RemoveMedia();
TRAPD(err, iCatMan->AddCategoryL(*category));
CleanupStack::PopAndDestroy(category);
test.Printf(_L("Adding second category gave error %d...\n"), err);
test(err == KErrNotReady);
}
void CCalRemovableMediaTest::CheckNumCategoriesL()
{
TInt newCategoryCount = iCatMan->CategoryCountL();
test.Printf(_L("Number of categories expected=%d, number found=%d\n"), iNumEntries, newCategoryCount);
test(newCategoryCount == iNumEntries);
}
void CCalRemovableMediaTest::DeleteCategoryL()
{
test.Next(_L("Test DeleteCategoryL\n"));
AddCategoryL(EFalse);
iNumEntries = iCatMan->CategoryCountL();
test(iCatMan->CategoryCountL() > 12); // 12 is the number of default categories, this checks at least one has been added
test.Printf(_L("Deleting category...\n"));
CCalCategory* cat = iCatMan->CategoryL(iNumEntries-1);
CleanupStack::PushL(cat);
RemoveMedia();
TRAPD(err, iCatMan->DeleteCategoryL(*cat, *this));
test.Printf(_L("DeleteCategoryL gave error %d\n"), err);
test(err == KErrNone);
CActiveScheduler::Start();
CleanupStack::PopAndDestroy(cat);
}
void CCalRemovableMediaTest::CheckDeleteCategory()
{
test(iError == KErrNotReady);
}
void CCalRemovableMediaTest::AddAttachmentL(TBool aTesting)
{
if (aTesting)
{
test.Next(_L("Test add attachment\n"));
}
GetNumEntriesL();
_LIT8(KBinaryData, "001010110100001010010001010110100001010010001010110100001010010001010110100001010010...is this binary?");
_LIT8(KGuid, "AddAttachmentL_guid");
HBufC8* guid = KGuid().AllocLC();
CCalEntry* entry = CCalEntry::NewL(CCalEntry::ETodo, guid, CCalEntry::EMethodNone, 0);
CleanupStack::Pop(guid);
CleanupStack::PushL(entry);
HBufC8* binaryData = KBinaryData().AllocLC();
CCalAttachment* attachment = CCalAttachment::NewFileL(binaryData);
CleanupStack::Pop(binaryData);
CleanupStack::PushL(attachment);
#ifdef TEST_MANUALLY
_LIT(KDrive, "d:");
TDriveName drive = KDrive();
attachment->FileAttachment()->SetDriveL(drive);
#endif
entry->AddAttachmentL(*attachment);
CleanupStack::Pop(attachment);
RPointerArray<CCalEntry> entryArray;
CleanupClosePushL(entryArray);
TInt success = 0;
entryArray.AppendL(entry);
if (aTesting)
{
RemoveMedia();
}
TRAPD(err, iTestLib->SynCGetEntryViewL().StoreL(entryArray, success));
if (aTesting)
{
test.Printf(_L("AddAttachmentL gave error %d\n"), err);
test(success == 0);
test(err == KErrNotReady);
}
else
{
test(success == entryArray.Count());
test(err == KErrNone);
}
CleanupStack::PopAndDestroy(&entryArray); // entryArray.Close()
CleanupStack::PopAndDestroy(entry);
}
void CCalRemovableMediaTest::UpdateAttachmentL()
{
test.Next(_L("Test update attachment\n"));
AddAttachmentL(EFalse);
GetNumEntriesL();
CCalAttachmentIterator* attachments = iAttMan->FetchAttachmentsL(CCalAttachmentManager::ESortBySizeLargestFirst);
CleanupStack::PushL(attachments);
test(attachments->HasMore());
CCalAttachment* currentAttachment = attachments->NextL();
CleanupStack::PushL(currentAttachment);
RArray<TCalLocalUid> localUids;
CleanupClosePushL(localUids);
iAttMan->EntriesReferencingFileAttachmentL(localUids, *currentAttachment);
test(localUids.Count() == 1);
CCalEntry* entry = iTestLib->SynCGetEntryViewL().FetchL(localUids[0]);
test(entry != NULL);
CleanupStack::PopAndDestroy(&localUids); // localUids.Close()
CleanupStack::PushL(entry);
entry->DeleteAttachmentL(*currentAttachment);
_LIT8(KBinaryData, "zxcvbnmzxcvbnmzxcvbnzmxcvbnmzxcvbznxmcvbnmzxcvbzxcvbnmzxvcbmn");
HBufC8* data = KBinaryData().AllocLC();
CCalAttachment* newAttachment = CCalAttachment::NewFileL(data);
CleanupStack::Pop(data);
CleanupStack::PushL(newAttachment);
entry->AddAttachmentL(*newAttachment);
CleanupStack::Pop(newAttachment);
RPointerArray<CCalEntry> entryArray;
CleanupClosePushL(entryArray);
RemoveMedia();
entryArray.AppendL(entry);
TInt success = 0;
TRAPD(err, iTestLib->SynCGetEntryViewL().StoreL(entryArray, success));
test.Printf(_L("UpdateAttachmentL gave error %d\n"), err);
test(success == 0);
test(err == KErrNotReady);
CleanupStack::PopAndDestroy(&entryArray); // entryArray.Close()
CleanupStack::PopAndDestroy(entry);
CleanupStack::PopAndDestroy(currentAttachment);
CleanupStack::PopAndDestroy(attachments);
}
void CCalRemovableMediaTest::DeleteAttachmentL()
{
test.Next(_L("Test delete attachment\n"));
// ensure at least one entry exists
iNumEntries = AttachmentFileCountL();
if (iNumEntries == 0)
{
AddAttachmentL(EFalse);
iNumEntries = AttachmentFileCountL();
test(iNumEntries != 0);
}
CCalAttachmentIterator* attachments = iAttMan->FetchAttachmentsL(CCalAttachmentManager::ESortBySizeLargestFirst);
CleanupStack::PushL(attachments);
test(attachments->HasMore());
CCalAttachment* currentAttachment = attachments->NextL();
CleanupStack::PushL(currentAttachment);
RArray<TCalLocalUid> localUids;
CleanupClosePushL(localUids);
iAttMan->EntriesReferencingFileAttachmentL(localUids, *currentAttachment);
test(localUids.Count() == 1);
RemoveMedia();
TInt success = 0;
TRAPD(err, iTestLib->SynCGetEntryViewL().DeleteL(localUids, success));
test.Printf(_L("DeleteAttachmentL gave error %d\n"), err);
test(err == KErrNotReady);
test(success == 0);
CleanupStack::PopAndDestroy(&localUids); // localUids.Close()
CleanupStack::PopAndDestroy(currentAttachment);
CleanupStack::PopAndDestroy(attachments);
}
void CCalRemovableMediaTest::CheckDeleteAttachmentL()
{
test.Printf(_L("Checking number of attachments: expected=%d...Number of entries found=%d\n"), iNumAttachments, AttachmentFileCountL());
test(iNumAttachments == AttachmentFileCountL());
}
void CCalRemovableMediaTest::ChangeAttachmentDriveL()
{
#ifdef TEST_MANUALLY
_LIT(KDriveC, "C:");
_LIT(KDriveD, "D:");
_LIT8(KGuidCopy, "guid_copy");
test.Next(_L("Create an attachment, copy it then set the drive to be different"));
// add an attachment
AddAttachmentL(EFalse);
// fetch the entry containing this attachment
CCalAttachmentIterator* attachments = iAttMan->FetchAttachmentsL(CCalAttachmentManager::ESortBySizeLargestFirst);
CleanupStack::PushL(attachments);
test(attachments->HasMore());
CCalAttachment* currentAttachment = attachments->NextL();
CleanupStack::PushL(currentAttachment);
RArray<TCalLocalUid> localUids;
CleanupClosePushL(localUids);
iAttMan->EntriesReferencingFileAttachmentL(localUids, *currentAttachment);
test(localUids.Count() == 1);
TInt luid1 = localUids[0];
CCalEntry* entry = iTestLib->SynCGetEntryViewL().FetchL(luid1);
test(entry != NULL);
CleanupStack::PopAndDestroy(&localUids);
CleanupStack::PopAndDestroy(currentAttachment);
CleanupStack::PopAndDestroy(attachments);
CleanupStack::PushL(entry);
// create a copy of the entry
HBufC8* guid = KGuidCopy().AllocLC();
CCalEntry* copyOfEntry = CCalEntry::NewL(entry->EntryTypeL(), guid, CCalEntry::EMethodNone, 0);
CleanupStack::Pop(guid);
CleanupStack::PushL(copyOfEntry);
copyOfEntry->CopyFromL(*entry, CCalEntry::EDontCopyId);
// edit the copy to place the attachment on a different drive
test(copyOfEntry->AttachmentCountL() == 1);
CCalAttachment* attach = copyOfEntry->AttachmentL(0);
test(attach != NULL);
attach->FileAttachment()->SetDriveL(KDriveC());
iTestLib->StoreEntryL(*copyOfEntry);
TCalLocalUid luid2 = copyOfEntry->LocalUidL();
CleanupStack::PopAndDestroy(copyOfEntry);
CleanupStack::PopAndDestroy(entry);
// fetch the copied entry and check its attachment
CCalEntry* fetchedCopiedEntry = iTestLib->SynCGetEntryViewL().FetchL(luid2);
test(fetchedCopiedEntry != NULL);
CleanupStack::PushL(fetchedCopiedEntry);
test(fetchedCopiedEntry->AttachmentCountL() == 1);
attach = fetchedCopiedEntry->AttachmentL(0);
test(attach != NULL);
attach->FileAttachment()->LoadBinaryDataL();
test(attach->Value().Length() > 10);
TDriveName drive = attach->FileAttachment()->Drive();
drive.UpperCase();
test(drive == KDriveC());
CleanupStack::PopAndDestroy(fetchedCopiedEntry);
// fetch the original entry
entry = iTestLib->SynCGetEntryViewL().FetchL(luid1);
CleanupStack::PushL(entry);
// create a copy of the entry
guid = KGuidCopy().AllocLC();
copyOfEntry = CCalEntry::NewL(entry->EntryTypeL(), guid, CCalEntry::EMethodNone, 0);
CleanupStack::Pop(guid);
CleanupStack::PushL(copyOfEntry);
copyOfEntry->CopyFromL(*entry, CCalEntry::EDontCopyId);
// edit the copy to place the attachment on the same drive (but change the flag)
test(copyOfEntry->AttachmentCountL() == 1);
attach = copyOfEntry->AttachmentL(0);
test(attach != NULL);
attach->FileAttachment()->SetDriveL(KDriveC());
attach->FileAttachment()->SetDriveL(KDriveD());
iTestLib->StoreEntryL(*copyOfEntry);
TCalLocalUid luid3 = copyOfEntry->LocalUidL();
CleanupStack::PopAndDestroy(copyOfEntry);
CleanupStack::PopAndDestroy(entry);
// fetch the copied entry and check its attachment
fetchedCopiedEntry = iTestLib->SynCGetEntryViewL().FetchL(luid3);
test(fetchedCopiedEntry != NULL);
CleanupStack::PushL(fetchedCopiedEntry);
test(fetchedCopiedEntry->AttachmentCountL() == 1);
attach = fetchedCopiedEntry->AttachmentL(0);
test(attach != NULL);
attach->FileAttachment()->LoadBinaryDataL();
test(attach->Value().Length() > 10);
drive = attach->FileAttachment()->Drive();
drive.UpperCase();
test(drive == KDriveD());
CleanupStack::PopAndDestroy(fetchedCopiedEntry);
#endif
}
void CCalRemovableMediaTest::DeleteInstanceL()
{
test.Next(_L("Test Delete Instance\n"));
RPointerArray<CCalInstance> instances;
CleanupResetAndDestroyPushL(instances);
iTestLib->FetchAllInstancesL(instances);
if (instances.Count() == 0)
{
InitialiseFileL();
iTestLib->FetchAllInstancesL(instances);
test(instances.Count() > 0);
}
iNumEntries = instances[0]->Entry().LocalUidL();
RemoveMedia();
test.Printf(_L("Deleting instance...\n"));
TRAPD(err, iTestLib->SynCGetInstanceViewL().DeleteL(instances[0], CalCommon::EThisAndAll));
test.Printf(_L("Deleting instance gave error %d...\n"), err);
test(err == KErrNotReady);
CleanupStack::PopAndDestroy(&instances); // instances.ResetAndDestroy()
}
void CCalRemovableMediaTest::CheckDeleteInstanceL()
{
test.Printf(_L("Checking instance not deleted...\n"));
CCalEntry* entry = iTestLib->SynCGetEntryViewL().FetchL(iNumEntries);
test(entry != NULL);
delete entry;
}
void CCalRemovableMediaTest::TestAfterMediaRemovedL()
{
test.Printf(_L("Testing read-only operations after media removed\n"));
StoreEntriesL(EFalse); // add some entries to begin with
StoreEntriesL(ETrue); // remove media
// test find instances after media removed
RPointerArray<CCalInstance> instances;
CleanupResetAndDestroyPushL(instances);
TRAPD(err, FindEntriesWithTextL(instances, KNullDesC()));
test(err == KErrNotReady);
CleanupStack::PopAndDestroy(&instances);
// test iterator
TRAP(err, iTestLib->GetIterL().FirstL());
test(err == KErrNotReady);
// test next instance
TCalTime startTime;
startTime.SetTimeLocalL(TCalTime::MinTime());
TRAP(err, iTestLib->SynCGetInstanceViewL().NextInstanceL(CalCommon::EIncludeAll, startTime));
test(err == KErrNotReady);
}
CCalRemovableMediaTest* CCalRemovableMediaTest::NewLC()
{
CCalRemovableMediaTest* app = new (ELeave) CCalRemovableMediaTest();
CleanupStack::PushL(app);
app->ConstructL();
return app;
}
void CCalRemovableMediaTest::ConstructL()
{
iTestLib = CCalTestLibrary::NewL();
#ifdef TEST_MANUALLY
#ifdef __WINS__
iCalendarName.Copy(_L("d:"));
iCalendarName.Append(KRemovableMediaTestFile);
#else
// find the first drive letter after drive c which exists
TDriveList list;
iTestLib->FileSession().DriveList(list);
TChar driveLetter;
TInt i = EDriveD;
while (i < EDriveZ)
{
TVolumeInfo volInfo;
TInt err = iTestLib->FileSession().Volume(volInfo, i);
if (err == KErrNone)
{
break;
}
++i;
}
User::LeaveIfError(iTestLib->FileSession().DriveToChar(i, driveLetter));
iCalendarName.Zero();
iCalendarName.Append(driveLetter);
test.Printf(_L("Using drive %S as external drive\n"), &iCalendarName);
test(iCalendarName.Length() == 1);
iCalendarName.Append(_L(":"));
iCalendarName.Append(KRemovableMediaTestFile);
#endif
#else
iCalendarName.Copy(_L("c:"));
iCalendarName.Append(KRemovableMediaTestFile);
#endif
TRAP_IGNORE(iTestLib->ReplaceFileL(iCalendarName));
}
void CCalRemovableMediaTest::SetupTestLibL()
{
#ifndef TEST_MANUALLY
iTestLib->FileSession().SetErrorCondition(0);
User::After(500000);
#endif
test.Printf(_L("Re-opening calendar file\n"));
iTestLib->OpenFileL(iCalendarName);
if (!iCatMan)
{
iCatMan = CCalCategoryManager::NewL(iTestLib->GetSession());
}
if (!iAttMan)
{
iAttMan = CCalAttachmentManager::NewL(iTestLib->GetSession(), *iTestLib);
CActiveScheduler::Start();
}
}
void CCalRemovableMediaTest::ClearTestLib()
{
delete iCatMan;
iCatMan = NULL;
delete iAttMan;
iAttMan = NULL;
}
CCalRemovableMediaTest::CCalRemovableMediaTest()
{
}
CCalRemovableMediaTest::~CCalRemovableMediaTest()
{
ClearTestLib();
delete iTestLib;
}
void CCalRemovableMediaTest::DoTestsL()
{
TInt step = EFirstStep;
while (step != EFinishedTests)
{
// this test suite can work only under debug mode because the file server failure
// simulation feature
#ifdef _DEBUG
NextStepL(step);
#endif
++step;
}
// clean up files
iTestLib->FileSession().SetErrorCondition(0);
User::After(500000);
iTestLib->DeleteFileL(KRemovableMediaTestFile, 1);
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* DoTestL()
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static void DoTestL()
{
#ifdef TEST_MANUALLY
test.Printf(_L("Manual test\n"));
#ifdef __WINS__
test.Printf(_L("\n"));
test.Printf(_L("Ensure the epoc.ini file is set up with the D: drive mapped to an external drive:\n"));
test.Printf(_L(" _epoc_drive_d f:\n"));
#endif
test.Printf(_L("\n"));
test.Printf(_L("Put an MMC card in the external drive and remove/replace it when prompted.\n"));
test.Printf(_L("Press any key.\n"));
test.Getch();
#endif
CCalRemovableMediaTest* testManager = CCalRemovableMediaTest::NewLC();
TPerformanceTimer timer(test);
timer.Start();
// Run the test suite
testManager->DoTestsL();
timer.Stop();
test.Printf(_L("Done\n"));
// printout performance time
timer.PrintOut();
CleanupStack::PopAndDestroy(testManager);
}
/**@SYMTestCaseID PIM-TCAL-REMOVABLE-MEDIA-0001*/TInt E32Main()
{
__UHEAP_MARK;
test.Start(_L("@SYMTESTCaseID:PIM-TCAL-REMOVABLE-MEDIA-0001 Calendar Interim API Removable Media test suite"));
test.Title();
CTrapCleanup* trapCleanup = CTrapCleanup::New();
if (!trapCleanup)
{
return KErrNoMemory;
}
CActiveScheduler* scheduler = new CActiveScheduler();
if (!scheduler)
{
delete trapCleanup;
return KErrNoMemory;
}
CActiveScheduler::Install(scheduler);
TRAPD(ret, DoTestL());
test(ret == KErrNone);
delete scheduler;
delete trapCleanup;
test.End();
test.Close();
__UHEAP_MARKEND;
return (KErrNone);
}