diff -r 000000000000 -r 72b543305e3a email/imap4mtm/imapsession/test/src/ctestimapsessioncreatesequenceset.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/email/imap4mtm/imapsession/test/src/ctestimapsessioncreatesequenceset.cpp Thu Dec 17 08:44:11 2009 +0200 @@ -0,0 +1,429 @@ +// 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; + } +