// Copyright (c) 2006-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 "ctestimapsessioncreatesequenceset.h"
#include "cimapsession.h"
CTestImapSessionCreateSequenceSet::CTestImapSessionCreateSequenceSet()
{}
CTestImapSessionCreateSequenceSet::~CTestImapSessionCreateSequenceSet()
{
iUids.Reset();
}
void CTestImapSessionCreateSequenceSet::SetupL()
{}
void CTestImapSessionCreateSequenceSet::TearDownL()
{
iUids.Reset();
}
/**
3 ==> 3
*/
void CTestImapSessionCreateSequenceSet::TestSingleValueL()
{
INFO_PRINTF1(_L("TestSingleValueL: 3 ==> 3"));
iUids.AppendL(3);
HBufC8* sequenceSet = CImapSession::CreateSequenceSetLC(iUids);
_LIT8(KCompare, "3");
ASSERT_EQUALS((TDesC8&)*sequenceSet, KCompare());
CleanupStack::PopAndDestroy(sequenceSet);
INFO_PRINTF1(_L("Complete"));
}
/**
1 2 ==> 1:2
*/
void CTestImapSessionCreateSequenceSet::TestSingleShortRangeL()
{
INFO_PRINTF1(_L("TestSingleShortRangeL: 1 2 ==> 1:2"));
iUids.AppendL(1);
iUids.AppendL(2);
HBufC8* sequenceSet = CImapSession::CreateSequenceSetLC(iUids);
_LIT8(KCompare, "1:2");
ASSERT_EQUALS((TDesC8&)*sequenceSet, KCompare());
CleanupStack::PopAndDestroy(sequenceSet);
INFO_PRINTF1(_L("Complete"));
}
/**
1 2 3 4 5 ==> 1:5
*/
void CTestImapSessionCreateSequenceSet::TestSingleMediumRangeL()
{
INFO_PRINTF1(_L("TestSingleMediumRangeL: 1 2 3 4 5 ==> 1:5"));
iUids.AppendL(1);
iUids.AppendL(2);
iUids.AppendL(3);
iUids.AppendL(4);
iUids.AppendL(5);
HBufC8* sequenceSet = CImapSession::CreateSequenceSetLC(iUids);
_LIT8(KCompare, "1:5");
ASSERT_EQUALS((TDesC8&)*sequenceSet, KCompare());
CleanupStack::PopAndDestroy(sequenceSet);
INFO_PRINTF1(_L("Complete"));
}
/**
1 2 3 4 5 ... 100 ==> 1:100
*/
void CTestImapSessionCreateSequenceSet::TestSingleLongRangeL()
{
INFO_PRINTF1(_L("TestSingleLongRangeL: 1 2 3 4 5 ... 100 ==> 1:100"));
for (TUint i=1; i<=100; i++)
{
iUids.AppendL(i);
}
HBufC8* sequenceSet = CImapSession::CreateSequenceSetLC(iUids);
_LIT8(KCompare, "1:100");
ASSERT_EQUALS((TDesC8&)*sequenceSet, KCompare());
CleanupStack::PopAndDestroy(sequenceSet);
INFO_PRINTF1(_L("Complete"));
}
/**
1 3 5 7 ==> 1,3,5,7
*/
void CTestImapSessionCreateSequenceSet::TestIndividualValuesL()
{
INFO_PRINTF1(_L("TestIndividualValuesL: 1 3 5 7 ==> 1,3,5,7"));
iUids.AppendL(1);
iUids.AppendL(3);
iUids.AppendL(5);
iUids.AppendL(7);
HBufC8* sequenceSet = CImapSession::CreateSequenceSetLC(iUids);
_LIT8(KCompare, "1,3,5,7");
ASSERT_EQUALS((TDesC8&)*sequenceSet, KCompare());
CleanupStack::PopAndDestroy(sequenceSet);
INFO_PRINTF1(_L("Complete"));
}
/**
5 8 9 10 11 ==> 5,8:11
*/
void CTestImapSessionCreateSequenceSet::TestSingleValueFollowedByRangeL()
{
INFO_PRINTF1(_L("TestSingleValueFollowedByRangeL: 5 8 9 10 11 ==> 5,8:11"));
iUids.AppendL(5);
iUids.AppendL(8);
iUids.AppendL(9);
iUids.AppendL(10);
iUids.AppendL(11);
HBufC8* sequenceSet = CImapSession::CreateSequenceSetLC(iUids);
_LIT8(KCompare, "5,8:11");
ASSERT_EQUALS((TDesC8&)*sequenceSet, KCompare());
CleanupStack::PopAndDestroy(sequenceSet);
INFO_PRINTF1(_L("Complete"));
}
/**
This tests the example given in the insource documentation for CreateSequenceSetLC
3 4 5 6 21 ==> 3:6,21
*/
void CTestImapSessionCreateSequenceSet::TestRangeFollowedBySingleValueL()
{
INFO_PRINTF1(_L("TestRangeFollowedBySingleValueL: 3 4 5 6 21"));
iUids.AppendL(3);
iUids.AppendL(4);
iUids.AppendL(5);
iUids.AppendL(6);
iUids.AppendL(21);
HBufC8* sequenceSet = CImapSession::CreateSequenceSetLC(iUids);
_LIT8(KCompare, "3:6,21");
ASSERT_EQUALS((TDesC8&)*sequenceSet, KCompare());
CleanupStack::PopAndDestroy(sequenceSet);
INFO_PRINTF1(_L("Complete"));
}
/**
1 3 4 6 ==> 1,3:4,6
*/
void CTestImapSessionCreateSequenceSet::TestShortRangeSurroundedBySingleValuesL()
{
INFO_PRINTF1(_L("TestShortRangeSurroundedBySingleValuesL: 1 3 4 6 ==> 1,3:4,6"));
iUids.AppendL(1);
iUids.AppendL(3);
iUids.AppendL(4);
iUids.AppendL(6);
HBufC8* sequenceSet = CImapSession::CreateSequenceSetLC(iUids);
_LIT8(KCompare, "1,3:4,6");
ASSERT_EQUALS((TDesC8&)*sequenceSet, KCompare());
CleanupStack::PopAndDestroy(sequenceSet);
INFO_PRINTF1(_L("Complete"));
}
/**
1 3 4 5 6 10 ==> 1,3:6,10
*/
void CTestImapSessionCreateSequenceSet::TestMediumRangeSurroundedBySingleValuesL()
{
INFO_PRINTF1(_L("TestMediumRangeSurroundedBySingleValuesL: 1 3 4 5 6 10 ==> 1,3:6,10"));
iUids.AppendL(1);
iUids.AppendL(3);
iUids.AppendL(4);
iUids.AppendL(5);
iUids.AppendL(6);
iUids.AppendL(10);
HBufC8* sequenceSet = CImapSession::CreateSequenceSetLC(iUids);
_LIT8(KCompare, "1,3:6,10");
ASSERT_EQUALS((TDesC8&)*sequenceSet, KCompare());
CleanupStack::PopAndDestroy(sequenceSet);
INFO_PRINTF1(_L("Complete"));
}
/**
5 6 7 8 11 15 16 17 18 ==> 5:8,11,15:18
*/
void CTestImapSessionCreateSequenceSet::TestSingleValueSurroundedByRangesL()
{
INFO_PRINTF1(_L("TestSingleValueSurroundedByRangesL: 5 6 7 8 11 15 16 17 18 ==> 5:8,11,15:18"));
TUint uids[] = { 5,6,7,8,11,15,16,17,18 };
TInt countUids = sizeof(uids) / sizeof(TUint);
DoTestL(uids, countUids, _L8("5:8,11,15:18"));
INFO_PRINTF1(_L("Complete"));
}
/**
10 11 12 15 16 ==> 10:12,15:16
*/
void CTestImapSessionCreateSequenceSet::TestTwoRangesL()
{
INFO_PRINTF1(_L("TestTwoRangesL: 10 11 12 15 16 ==> 10:12,15:16"));
iUids.AppendL(10);
iUids.AppendL(11);
iUids.AppendL(12);
iUids.AppendL(15);
iUids.AppendL(16);
HBufC8* sequenceSet = CImapSession::CreateSequenceSetLC(iUids);
_LIT8(KCompare, "10:12,15:16");
ASSERT_EQUALS((TDesC8&)*sequenceSet, KCompare());
CleanupStack::PopAndDestroy(sequenceSet);
INFO_PRINTF1(_L("Complete"));
}
/**
1 2 3 5 6 7 10 11 12 13 ==> 1:3,5:7,10:13
*/
void CTestImapSessionCreateSequenceSet::TestThreeRangesL()
{
INFO_PRINTF1(_L("TestThreeRangesL: 1 2 3 5 6 7 10 11 12 13 ==> 1:3,5:7,10:13"));
TUint uids[] = { 1,2,3,5,6,7,10,11,12,13 };
TInt countUids = sizeof(uids) / sizeof(TUint);
DoTestL(uids, countUids, _L8("1:3,5:7,10:13"));
INFO_PRINTF1(_L("Complete"));
}
/**
2,4,6,8,10,...,200 ==> 2,4,6,8,10,...,200
CImapSession::CreateSequenceSetLC() uses an expandable buffer to build the
sequence set string. This test checks that the buffer does indeed expand
when required.
*/
void CTestImapSessionCreateSequenceSet::TestLongResultStringL()
{
INFO_PRINTF1(_L("TestLongResultStringL: 2,4,6,8,10,...,200 ==> 2,4,6,8,10,...,200"));
TBuf8<400> bufExpectedResult;
iUids.AppendL(2);
bufExpectedResult.Append(_L8("2"));
for (TUint i=2; i<=100; i++)
{
iUids.AppendL(i*2);
bufExpectedResult.AppendFormat(_L8(",%d"), i*2);
}
HBufC8* sequenceSet = CImapSession::CreateSequenceSetLC(iUids);
ASSERT_EQUALS((TDesC8&)*sequenceSet, (TDesC8&)bufExpectedResult);
CleanupStack::PopAndDestroy(sequenceSet);
INFO_PRINTF1(_L("Complete"));
}
/**
10 11 12 15 16 ==> 10:12,15:16
*/
void CTestImapSessionCreateSequenceSet::TestOutOfOrderSingleRangeL()
{
INFO_PRINTF1(_L("TestOutOfOrderSingleRangeL: 10 11 12 15 16 ==> 10:12,15:16"));
iUids.AppendL(10);
iUids.AppendL(11);
iUids.AppendL(12);
iUids.AppendL(15);
iUids.AppendL(16);
HBufC8* sequenceSet = CImapSession::CreateSequenceSetLC(iUids);
_LIT8(KCompare, "10:12,15:16");
ASSERT_EQUALS((TDesC8&)*sequenceSet, KCompare());
CleanupStack::PopAndDestroy(sequenceSet);
INFO_PRINTF1(_L("Complete"));
}
/**
16 10 3 7 14 5 15 4 12 13 6 ==> 3:7,12:16
*/
void CTestImapSessionCreateSequenceSet::TestOutOfOrderMixedValuesL()
{
INFO_PRINTF1(_L("TestOutOfOrderMixedValuesL: 16 3 7 14 5 15 4 12 13 6 ==> 3:7,10,12:16"));
TUint uids[] = { 16,10,3,7,14,5,15,4,12,13,6 };
TInt countUids = sizeof(uids) / sizeof(TUint);
DoTestL(uids, countUids, _L8("3:7,10,12:16"));
INFO_PRINTF1(_L("Complete"));
}
/**
3 3 4 5 5 5 6 6 7 7 7 7 ==> 3:7
*/
void CTestImapSessionCreateSequenceSet::TestDuplicatesSingleRangeL()
{
INFO_PRINTF1(_L("TestDuplicatesSingleRangeL: 3 3 4 5 5 5 6 6 7 7 7 7 ==> 3:7"));
TUint uids[] = { 3,3,4,5,5,5,6,6,7,7,7,7 };
TInt countUids = sizeof(uids) / sizeof(TUint);
DoTestL(uids, countUids, _L8("3:7"));
INFO_PRINTF1(_L("Complete"));
}
/**
12 12 15 15 16 20 21 21 22 22 30 30 30 ==> 12,15:16,20:22:30
*/
void CTestImapSessionCreateSequenceSet::TestDuplicatesMixedValuesL()
{
INFO_PRINTF1(_L("TestDuplicatesMixedValuesL: 12 12 15 15 16 20 21 21 22 22 30 30 30 ==> 12,15:16,20:22:30"));
TUint uids[] = { 12,12,15,15,16,20,21,21,22,22,30,30,30 };
TInt countUids = sizeof(uids) / sizeof(TUint);
DoTestL(uids, countUids, _L8("12,15:16,20:22,30"));
INFO_PRINTF1(_L("Complete"));
}
/**
3 7 16 20 10 11 10 15 11 2 2 1 20 3 4 7 10 2 14 20 15 ==> 1:4,7,10:11,14:16,20
*/
void CTestImapSessionCreateSequenceSet::TestDuplicatesAndOutOfOrderMixedValuesL()
{
INFO_PRINTF1(_L("TestDuplicatesAndOutOfOrderMixedValuesL: 3 7 16 20 10 11 10 15 11 2 2 1 20 3 4 7 10 2 14 20 15 ==> 1:4,7,10:11,14:16,20"));
TUint uids[] = { 3,7,16,20,10,11,10,15,11,2,2,1,20,3,4,7,10,2,14,20,15 };
TInt countUids = sizeof(uids) / sizeof(TUint);
DoTestL(uids, countUids, _L8("1:4,7,10:11,14:16,20"));
INFO_PRINTF1(_L("Complete"));
}
void CTestImapSessionCreateSequenceSet::DoTestL(TUint* aUids, TInt aCountUids, const TDesC8& aExpectedResult)
{
for (TInt i = 0; i < aCountUids; i++)
{
iUids.AppendL(aUids[i]);
}
HBufC8* sequenceSet = CImapSession::CreateSequenceSetLC(iUids);
ASSERT_EQUALS((TDesC8&)*sequenceSet, aExpectedResult);
CleanupStack::PopAndDestroy(sequenceSet);
}
CTestSuite* CTestImapSessionCreateSequenceSet::CreateSuiteL(const TDesC& aName)
// static
{
SUB_SUITE;
ADD_TEST_STEP(TestSingleValueL);
ADD_TEST_STEP(TestSingleShortRangeL);
ADD_TEST_STEP(TestSingleMediumRangeL);
ADD_TEST_STEP(TestSingleLongRangeL);
ADD_TEST_STEP(TestIndividualValuesL);
ADD_TEST_STEP(TestSingleValueFollowedByRangeL);
ADD_TEST_STEP(TestRangeFollowedBySingleValueL);
ADD_TEST_STEP(TestShortRangeSurroundedBySingleValuesL);
ADD_TEST_STEP(TestMediumRangeSurroundedBySingleValuesL);
ADD_TEST_STEP(TestSingleValueSurroundedByRangesL);
ADD_TEST_STEP(TestTwoRangesL);
ADD_TEST_STEP(TestThreeRangesL);
ADD_TEST_STEP(TestLongResultStringL);
ADD_TEST_STEP(TestOutOfOrderSingleRangeL);
ADD_TEST_STEP(TestOutOfOrderMixedValuesL);
ADD_TEST_STEP(TestDuplicatesSingleRangeL);
ADD_TEST_STEP(TestDuplicatesMixedValuesL);
ADD_TEST_STEP(TestDuplicatesAndOutOfOrderMixedValuesL);
END_SUITE;
}