|
62
|
1 |
/*
|
|
|
2 |
* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies).
|
|
|
3 |
* All rights reserved.
|
|
|
4 |
* This component and the accompanying materials are made available
|
|
|
5 |
* under the terms of "Eclipse Public License v1.0"
|
|
|
6 |
* which accompanies this distribution, and is available
|
|
|
7 |
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
|
|
|
8 |
*
|
|
|
9 |
* Initial Contributors:
|
|
|
10 |
* Nokia Corporation - initial contribution.
|
|
|
11 |
*
|
|
|
12 |
* Contributors:
|
|
|
13 |
*
|
|
|
14 |
* Description: MpxCollectionTest class member functions
|
|
|
15 |
*
|
|
|
16 |
*/
|
|
|
17 |
|
|
|
18 |
// INCLUDE FILES
|
|
|
19 |
#include <e32def.h>
|
|
|
20 |
#include <bamdesca.h>
|
|
|
21 |
#include <mpxcollectionutility.h>
|
|
|
22 |
#include <mpxmedia.h>
|
|
|
23 |
#include <mpxcollectionplaylist.h>
|
|
|
24 |
#include <mpxharvesterutility.h>
|
|
|
25 |
#include <mpxcollectionmessage.h>
|
|
|
26 |
#include <mpxcommonframeworkdefs.h>
|
|
|
27 |
#include <mpxmediageneraldefs.h>
|
|
|
28 |
#include <mpxmediaarray.h>
|
|
|
29 |
#include <mpxmediacontainerdefs.h>
|
|
|
30 |
#include <mpxmediamusicdefs.h>
|
|
|
31 |
#include <mpxmediaaudiodefs.h>
|
|
|
32 |
#include <mpxmediadrmdefs.h>
|
|
|
33 |
#include <mpxcollectionpath.h>
|
|
|
34 |
#include <mpxattribute.h>
|
|
|
35 |
#include <stiflogger.h>
|
|
|
36 |
#include "consolemain.h"
|
|
|
37 |
#include "mpxcollectiontest.h"
|
|
|
38 |
#include "collectiontests.h"
|
|
|
39 |
|
|
|
40 |
_LIT(KTestFailed, "Failed");
|
|
|
41 |
_LIT(KTestPassed, "Passed");
|
|
|
42 |
|
|
|
43 |
|
|
|
44 |
// CONSTANTS
|
|
|
45 |
|
|
|
46 |
// ============================ MEMBER FUNCTIONS ===============================
|
|
|
47 |
|
|
|
48 |
// -----------------------------------------------------------------------------
|
|
|
49 |
// CMpxCollectionTest::NewL
|
|
|
50 |
// Two-phased constructor.
|
|
|
51 |
// -----------------------------------------------------------------------------
|
|
|
52 |
//
|
|
|
53 |
CMpxCollectionTest* CMpxCollectionTest::NewL()
|
|
|
54 |
{
|
|
|
55 |
CMpxCollectionTest* self = new (ELeave) CMpxCollectionTest;
|
|
|
56 |
|
|
|
57 |
CleanupStack::PushL( self );
|
|
|
58 |
self->ConstructL();
|
|
|
59 |
CleanupStack::Pop();
|
|
|
60 |
|
|
|
61 |
return self;
|
|
|
62 |
}
|
|
|
63 |
|
|
|
64 |
// -----------------------------------------------------------------------------
|
|
|
65 |
// CMpxCollectionTest::CMpxCollectionTest
|
|
|
66 |
// C++ default constructor can NOT contain any code, that
|
|
|
67 |
// might leave.
|
|
|
68 |
// -----------------------------------------------------------------------------
|
|
|
69 |
//
|
|
|
70 |
CMpxCollectionTest::CMpxCollectionTest()
|
|
|
71 |
: iMainConsole(NULL)
|
|
|
72 |
{
|
|
|
73 |
}
|
|
|
74 |
|
|
|
75 |
// -----------------------------------------------------------------------------
|
|
|
76 |
// CMpxCollectionTest::ConstructL
|
|
|
77 |
// Symbian 2nd phase constructor can leave.
|
|
|
78 |
// -----------------------------------------------------------------------------
|
|
|
79 |
//
|
|
|
80 |
void CMpxCollectionTest::ConstructL()
|
|
|
81 |
{
|
|
|
82 |
iScheduler = new(ELeave) CActiveScheduler;
|
|
|
83 |
CActiveScheduler::Install(iScheduler);
|
|
|
84 |
|
|
|
85 |
iLogger = CStifLogger::NewL( _L("c:\\"),
|
|
|
86 |
_L("MpxCollectionTest.html"),
|
|
|
87 |
CStifLogger::EHtml,
|
|
|
88 |
CStifLogger::EFile,
|
|
|
89 |
ETrue,
|
|
|
90 |
ETrue,
|
|
|
91 |
ETrue,
|
|
|
92 |
EFalse,
|
|
|
93 |
ETrue,
|
|
|
94 |
ETrue);
|
|
|
95 |
|
|
|
96 |
iLogger->Log(_L("===MpxCollectionTest constructed==="));
|
|
|
97 |
}
|
|
|
98 |
|
|
|
99 |
// -----------------------------------------------------------------------------
|
|
|
100 |
// Destructor
|
|
|
101 |
// -----------------------------------------------------------------------------
|
|
|
102 |
CMpxCollectionTest::~CMpxCollectionTest()
|
|
|
103 |
{
|
|
|
104 |
if(iMainConsole)
|
|
|
105 |
{
|
|
|
106 |
delete iMainConsole;
|
|
|
107 |
iMainConsole = NULL;
|
|
|
108 |
}
|
|
|
109 |
if(iLogger)
|
|
|
110 |
{
|
|
|
111 |
delete iLogger;
|
|
|
112 |
iLogger = NULL;
|
|
|
113 |
}
|
|
|
114 |
if(iScheduler)
|
|
|
115 |
{
|
|
|
116 |
delete iScheduler;
|
|
|
117 |
iScheduler = NULL;
|
|
|
118 |
}
|
|
|
119 |
}
|
|
|
120 |
|
|
|
121 |
// -----------------------------------------------------------------------------
|
|
|
122 |
// CMpxCollectionTest::InitL
|
|
|
123 |
// InitL is used to initialize the Test Module.
|
|
|
124 |
// -----------------------------------------------------------------------------
|
|
|
125 |
//
|
|
|
126 |
TInt CMpxCollectionTest::InitL(
|
|
|
127 |
TFileName& /*aIniFile*/,
|
|
|
128 |
TBool /*aFirstTime*/ )
|
|
|
129 |
{
|
|
|
130 |
return KErrNone;
|
|
|
131 |
}
|
|
|
132 |
|
|
|
133 |
// -----------------------------------------------------------------------------
|
|
|
134 |
// CMpxCollectionTest::GetTestCasesL
|
|
|
135 |
// GetTestCases is used to inquire test cases from the Test Module. Test
|
|
|
136 |
// cases are stored to array of test cases. The Test Framework will be
|
|
|
137 |
// the owner of the data in the RPointerArray after GetTestCases return
|
|
|
138 |
// and it does the memory deallocation.
|
|
|
139 |
// -----------------------------------------------------------------------------
|
|
|
140 |
//
|
|
|
141 |
TInt CMpxCollectionTest::GetTestCasesL(
|
|
|
142 |
const TFileName& /*aConfig*/,
|
|
|
143 |
RPointerArray<TTestCaseInfo>& aTestCases )
|
|
|
144 |
{
|
|
|
145 |
|
|
|
146 |
// Loop through all test cases and create new
|
|
|
147 |
// TTestCaseInfo items and append items to aTestCase array
|
|
|
148 |
for( TInt i = 0; Case(i).iMethod != NULL; i++ )
|
|
|
149 |
{
|
|
|
150 |
|
|
|
151 |
// Allocate new TTestCaseInfo from heap for a testcase definition.
|
|
|
152 |
TTestCaseInfo* newCase = new( ELeave ) TTestCaseInfo();
|
|
|
153 |
|
|
|
154 |
// PushL TTestCaseInfo to CleanupStack.
|
|
|
155 |
CleanupStack::PushL( newCase );
|
|
|
156 |
|
|
|
157 |
// Set number for the testcase.
|
|
|
158 |
// When the testcase is run, this comes as a parameter to RunTestCaseL.
|
|
|
159 |
newCase->iCaseNumber = i;
|
|
|
160 |
|
|
|
161 |
// Set title for the test case. This is shown in UI to user.
|
|
|
162 |
newCase->iTitle.Copy( Case(i).iCaseName );
|
|
|
163 |
|
|
|
164 |
// Append TTestCaseInfo to the testcase array. After appended
|
|
|
165 |
// successfully the TTestCaseInfo object is owned (and freed)
|
|
|
166 |
// by the TestServer.
|
|
|
167 |
User::LeaveIfError(aTestCases.Append ( newCase ) );
|
|
|
168 |
|
|
|
169 |
// Pop TTestCaseInfo from the CleanupStack.
|
|
|
170 |
CleanupStack::Pop( newCase );
|
|
|
171 |
}
|
|
|
172 |
|
|
|
173 |
return KErrNone;
|
|
|
174 |
|
|
|
175 |
}
|
|
|
176 |
|
|
|
177 |
// -----------------------------------------------------------------------------
|
|
|
178 |
// CMpxCollectionTest::RunTestCaseL
|
|
|
179 |
// RunTestCaseL is used to run an individual test case specified
|
|
|
180 |
// by aTestCase. Test cases that can be run may be requested from
|
|
|
181 |
// Test Module by GetTestCases method before calling RunTestCase.
|
|
|
182 |
// -----------------------------------------------------------------------------
|
|
|
183 |
//
|
|
|
184 |
TInt CMpxCollectionTest::RunTestCaseL(
|
|
|
185 |
const TInt aCaseNumber,
|
|
|
186 |
const TFileName& /*aConfig*/,
|
|
|
187 |
TTestResult& aResult )
|
|
|
188 |
{
|
|
|
189 |
|
|
|
190 |
// Return value
|
|
|
191 |
TInt execStatus = KErrNone;
|
|
|
192 |
|
|
|
193 |
// Get the pointer to test case function
|
|
|
194 |
TCaseInfo tmp = Case ( aCaseNumber );
|
|
|
195 |
|
|
|
196 |
// Check that case number was valid
|
|
|
197 |
if ( tmp.iMethod != NULL )
|
|
|
198 |
{
|
|
|
199 |
iLogger->Log( _L( "Running test for: %S" ), &(tmp.iCaseName) );
|
|
|
200 |
|
|
|
201 |
// Valid case was found, call it via function pointer
|
|
|
202 |
iMethod = tmp.iMethod;
|
|
|
203 |
execStatus = ( this->*iMethod )( aResult );
|
|
|
204 |
|
|
|
205 |
// Write log information
|
|
|
206 |
if ( aResult.iResult == KErrNone )
|
|
|
207 |
{
|
|
|
208 |
iLogger->Log( _L( "Result: %S" ), &KTestPassed );
|
|
|
209 |
iLogger->Log( _L( "" ) );
|
|
|
210 |
}
|
|
|
211 |
else
|
|
|
212 |
{
|
|
|
213 |
iLogger->Log( _L( "Result: %S" ), &KTestFailed );
|
|
|
214 |
iLogger->Log( _L( "Description: %S" ), &(aResult.iResultDes) );
|
|
|
215 |
iLogger->Log( _L( "" ) );
|
|
|
216 |
}
|
|
|
217 |
}
|
|
|
218 |
else
|
|
|
219 |
{
|
|
|
220 |
// Valid case was not found, return error.
|
|
|
221 |
execStatus = KErrNotFound;
|
|
|
222 |
}
|
|
|
223 |
|
|
|
224 |
// Return case execution status (not the result of the case execution)
|
|
|
225 |
return execStatus;
|
|
|
226 |
|
|
|
227 |
}
|
|
|
228 |
|
|
|
229 |
// -----------------------------------------------------------------------------
|
|
|
230 |
// CMpxCollectionTest::Case
|
|
|
231 |
// Returns a test case by number.
|
|
|
232 |
//
|
|
|
233 |
// This function contains an array of all available test cases
|
|
|
234 |
// i.e pair of case name and test function. If case specified by parameter
|
|
|
235 |
// aCaseNumber is found from array, then that item is returned.
|
|
|
236 |
//
|
|
|
237 |
// The reason for this rather complicated function is to specify all the
|
|
|
238 |
// test cases only in one place. It is not necessary to understand how
|
|
|
239 |
// function pointers to class member functions works when adding new test
|
|
|
240 |
// cases. See function body for instructions how to add new test case.
|
|
|
241 |
// -----------------------------------------------------------------------------
|
|
|
242 |
//
|
|
|
243 |
const TCaseInfo CMpxCollectionTest::Case (
|
|
|
244 |
const TInt aCaseNumber ) const
|
|
|
245 |
{
|
|
|
246 |
|
|
|
247 |
/**
|
|
|
248 |
* To add new test cases, implement new test case function and add new
|
|
|
249 |
* line to KCases array specify the name of the case and the function
|
|
|
250 |
* doing the test case
|
|
|
251 |
* In practice, do following
|
|
|
252 |
* 1) Make copy of existing test case function and change its name
|
|
|
253 |
* and functionality. Note that the function must be added to
|
|
|
254 |
* MpxCollectionTest.cpp file and to MpxCollectionTest.h
|
|
|
255 |
* header file.
|
|
|
256 |
* 2) Add entry to following KCases array either by using FUNCENTRY or
|
|
|
257 |
* ENTRY macro.
|
|
|
258 |
* ENTRY macro takes two parameters: test case name and test case
|
|
|
259 |
* function name.
|
|
|
260 |
* FUNCENTRY macro takes only test case function name as a parameter and uses
|
|
|
261 |
* that as a test case name and test case function name.
|
|
|
262 |
*/
|
|
|
263 |
|
|
|
264 |
static TCaseInfoInternal const KCases[] =
|
|
|
265 |
{
|
|
|
266 |
// To add new test cases, add new items to this array
|
|
|
267 |
ENTRY( "Test0001-OpenL() Collection 1 - NewL Default, OpenL Default + case 11", Test0001L),
|
|
|
268 |
//ENTRY( "Test0002-OpenL() blank", Test0002L),
|
|
|
269 |
//ENTRY( "Test0003-OpenL() blank", Test0003L),
|
|
|
270 |
//ENTRY( "Test0004-OpenL() blank", Test0004L),
|
|
|
271 |
//ENTRY( "Test0005-OpenL() blank", Test0005L),
|
|
|
272 |
//ENTRY( "Test0006-OpenL() blank", Test0006L),
|
|
|
273 |
//ENTRY( "Test0007-OpenL() blank", Test0007L),
|
|
|
274 |
//ENTRY( "Test0008-OpenL() blank", Test0008L),
|
|
|
275 |
//ENTRY( "Test0009-OpenL() blank", Test0009L),
|
|
|
276 |
//ENTRY( "Test0010-OpenL() blank", Test0010L),
|
|
|
277 |
ENTRY( "Test0011-OpenL() Collection 2 - NewL(Isolated), OpenL(Default)", Test0011L),
|
|
|
278 |
//ENTRY( "Test0012-OpenL() blank", Test0012L),
|
|
|
279 |
ENTRY( "Test0013-OpenL() NewL(Isolated), OpenL(EMPXOpenGroupOrPlaylist)", Test0013L),
|
|
|
280 |
//ENTRY( "Test0014-OpenL() blank", Test0014L),
|
|
|
281 |
ENTRY( "Test0015-OpenL() NewL(Isolated), OpenL(EMPXOpenAllItems)", Test0015L),
|
|
|
282 |
//ENTRY( "Test0016-OpenL() blank", Test0016L),
|
|
|
283 |
ENTRY( "Test0017-OpenL() NewL(Isolated), OpenL(EMPXOpenNoPlaylist)", Test0017L),
|
|
|
284 |
//ENTRY( "Test0018-OpenL() blank", Test0018L),
|
|
|
285 |
ENTRY( "Test0019-OpenL() Collection 2 - NewL(Isolated), OpenL(EMPXOpenPlaylistOnly)", Test0019L),
|
|
|
286 |
ENTRY( "Test0020-OpenL() Collection 2 - Open(), Close()", Test0020L),
|
|
|
287 |
ENTRY( "Test0021-OpenL() NewL Default, OpenL(EMPXOpenDefault)", Test0021L),
|
|
|
288 |
//ENTRY( "Test0022-OpenL() NewL Default, OpenL(KColTestPluginNormIndex,EMPXOpenDefault)", Test0022L),
|
|
|
289 |
//ENTRY( "Test0023-OpenL() same as 21", Test0023L),
|
|
|
290 |
//ENTRY( "Test0024-OpenL() NewL Default, OpenL(EMPXOpenGroupOrPlaylist)", Test0024L),
|
|
|
291 |
//ENTRY( "Test0025-OpenL() NewL Default, OpenL(EMPXOpenAllItems)", Test0025L),
|
|
|
292 |
//ENTRY( "Test0026-OpenL() NewL Default, OpenL(EMPXOpenNoPlaylist)", Test0026L),
|
|
|
293 |
//ENTRY( "Test0027-OpenL() NewL Default, OpenL(EMPXOpenPlaylistOnly)", Test0027L),
|
|
|
294 |
//ENTRY( "Test0028-OpenL() same as 21", Test0028L),
|
|
|
295 |
//ENTRY( "Test0029-OpenL() NewL Default, OpenL(0,EMPXOpenDefault)", Test0029L),
|
|
|
296 |
//ENTRY( "Test0030-OpenL() NewL Default, OpenL(EMPXOpenDefault)", Test0030L),
|
|
|
297 |
//ENTRY( "Test0031-OpenL() NewL Default, OpenL(EMPXOpenDefault)", Test0031L),
|
|
|
298 |
//ENTRY( "Test0032-OpenL() NewL Default, OpenL(EMPXOpenDefault)", Test0032L),
|
|
|
299 |
//ENTRY( "Test0033-OpenL() NewL Default, OpenL(EMPXOpenDefault)", Test0033L),
|
|
|
300 |
//ENTRY( "Test0034-OpenL() NewL Default, OpenL(EMPXOpenDefault)", Test0034L),
|
|
|
301 |
//ENTRY( "Test0035-OpenL() NewL Default, OpenL(EMPXOpenDefault)", Test0035L),
|
|
|
302 |
ENTRY( "Test0036-OpenL() NewL Default, OpenL(EMPXOpenDefault)", Test0036L),
|
|
|
303 |
//ENTRY( "Test0037-OpenL() NewL Default, OpenL(EMPXOpenDefault)", Test0037L),
|
|
|
304 |
//ENTRY( "Test0038-OpenL() NewL Default, OpenL(EMPXOpenDefault)", Test0038L),
|
|
|
305 |
//ENTRY( "Test0039-OpenL() NewL Default, OpenL(EMPXOpenDefault)", Test0039L),
|
|
|
306 |
//ENTRY( "Test0040-OpenL() NewL Default, OpenL(EMPXOpenDefault)", Test0040L),
|
|
|
307 |
//ENTRY( "Test0041-OpenL() NewL Default, OpenL(EMPXOpenDefault)", Test0041L),
|
|
|
308 |
ENTRY( "Test0042-Filters,Path,UID", Test0042L),
|
|
|
309 |
//ENTRY( "Test0043- Filters,Path,UID", Test0043L),
|
|
|
310 |
//ENTRY( "Test0044- Filters,Path,UID", Test0044L),
|
|
|
311 |
//ENTRY( "Test0045- Filters,Path,UID", Test0045L),
|
|
|
312 |
//ENTRY( "Test0046- Filters,Path,UID", Test0046L),
|
|
|
313 |
//ENTRY( "Test0047- Filters,Path,UID", Test0047L),
|
|
|
314 |
//ENTRY( "Test0048- Filters,Path,UID", Test0048L),
|
|
|
315 |
//ENTRY( "Test0049- Filters,Path,UID", Test0049L),
|
|
|
316 |
//ENTRY( "Test0050- Filters,Path,UID", Test0050L),
|
|
|
317 |
//ENTRY( "Test0051- Filters,Path,UID", Test0051L),
|
|
|
318 |
//ENTRY( "Test0052- Filters,Path,UID", Test0052L),
|
|
|
319 |
//ENTRY( "Test0053- Filters,Path,UID", Test0053L),
|
|
|
320 |
ENTRY( "Test0054-Filters,Path,UID", Test0054L),
|
|
|
321 |
//ENTRY( "Test0055- PathL()", Test0055L),
|
|
|
322 |
//ENTRY( "Test0056- PathL()", Test0056L),
|
|
|
323 |
//ENTRY( "Test0057- PathL()", Test0057L),
|
|
|
324 |
//ENTRY( "Test0058- PathL()", Test0058L),
|
|
|
325 |
//ENTRY( "Test0059- Back()", Test0059L),
|
|
|
326 |
//ENTRY( "Test0060- Back()", Test0060L),
|
|
|
327 |
//ENTRY( "Test0061- Back()", Test0061L),
|
|
|
328 |
//ENTRY( "Test0062- Back()", Test0062L),
|
|
|
329 |
//ENTRY( "Test0063- Back()", Test0063L),
|
|
|
330 |
//ENTRY( "Test0064- Empty", Test0064L),
|
|
|
331 |
//ENTRY( "Test0065- Empty", Test0065L),
|
|
|
332 |
//ENTRY( "Test0066- Empty", Test0066L),
|
|
|
333 |
//ENTRY( "Test0067- Empty", Test0067L),
|
|
|
334 |
//ENTRY( "Test0068- Empty", Test0068L),
|
|
|
335 |
//ENTRY( "Test0069- Empty", Test0069L),
|
|
|
336 |
ENTRY( "Test0070-AddL()", Test0070L),
|
|
|
337 |
//ENTRY( "Test0071- AddL()", Test0071L),
|
|
|
338 |
//ENTRY( "Test0072- AddL()", Test0072L),
|
|
|
339 |
//ENTRY( "Test0073- AddL()", Test0073L),
|
|
|
340 |
//ENTRY( "Test0074- AddL()", Test0074L),
|
|
|
341 |
//ENTRY( "Test0075- AddL()", Test0075L),
|
|
|
342 |
//ENTRY( "Test0076- AddL()", Test0076L),
|
|
|
343 |
//ENTRY( "Test0077- AddL()", Test0077L),
|
|
|
344 |
//ENTRY( "Test0078- AddL()", Test0078L),
|
|
|
345 |
//ENTRY( "Test0079- AddL()", Test0079L),
|
|
|
346 |
//ENTRY( "Test0080- AddL()", Test0080L),
|
|
|
347 |
//ENTRY( "Test0081- AddL()", Test0081L),
|
|
|
348 |
ENTRY( "Test0082-RemoveL()", Test0082L),
|
|
|
349 |
//ENTRY( "Test0083- RemoveL()", Test0083L),
|
|
|
350 |
//ENTRY( "Test0084- RemoveL()", Test0084L),
|
|
|
351 |
//ENTRY( "Test0085- RemoveL()", Test0085L),
|
|
|
352 |
//ENTRY( "Test0086- RemoveL()", Test0086L),
|
|
|
353 |
//ENTRY( "Test0087- RemoveL()", Test0087L),
|
|
|
354 |
//ENTRY( "Test0088- RemoveL()", Test0088L),
|
|
|
355 |
//ENTRY( "Test0089- RemoveL()", Test0089L),
|
|
|
356 |
//ENTRY( "Test0090- RemoveL()", Test0090L),
|
|
|
357 |
//ENTRY( "Test0091- RemoveL()", Test0091L),
|
|
|
358 |
//ENTRY( "Test0092- RemoveL()", Test0092L),
|
|
|
359 |
//ENTRY( "Test0093- RemoveL()", Test0093L),
|
|
|
360 |
//ENTRY( "Test0094- RemoveL()", Test0094L),
|
|
|
361 |
//ENTRY( "Test0095- RemoveL()", Test0095L),
|
|
|
362 |
//ENTRY( "Test0096- RemoveL()", Test0096L),
|
|
|
363 |
//ENTRY( "Test0097- RemoveL()", Test0097L),
|
|
|
364 |
//ENTRY( "Test0098- RemoveL()", Test0098L),
|
|
|
365 |
//ENTRY( "Test0099- RemoveL()", Test0099L),
|
|
|
366 |
//ENTRY( "Test0100- RemoveL()", Test0100L),
|
|
|
367 |
ENTRY( "Test0101-SetSync()", Test0101L),
|
|
|
368 |
//ENTRY( "Test0102- SetSync()", Test0102L),
|
|
|
369 |
//ENTRY( "Test0103- SetSync()", Test0103L),
|
|
|
370 |
//ENTRY( "Test0104- SetSync()", Test0104L),
|
|
|
371 |
//ENTRY( "Test0105- SetSync()", Test0105L),
|
|
|
372 |
//ENTRY( "Test0106- SetSync()", Test0106L),
|
|
|
373 |
//ENTRY( "Test0107- SetSync()", Test0107L),
|
|
|
374 |
//ENTRY( "Test0108- SetSync()", Test0108L),
|
|
|
375 |
//ENTRY( "Test0109- SetSync()", Test0109L),
|
|
|
376 |
ENTRY( "Test0110-SetL()", Test0110L),
|
|
|
377 |
//ENTRY( "Test0111- SetL()", Test0111L),
|
|
|
378 |
//ENTRY( "Test0112- SetL()", Test0112L),
|
|
|
379 |
//ENTRY( "Test0113- SetL()", Test0113L),
|
|
|
380 |
//ENTRY( "Test0114- SetL()", Test0114L),
|
|
|
381 |
//ENTRY( "Test0115- SetL()", Test0115L),
|
|
|
382 |
//ENTRY( "Test0116- SetL()", Test0116L),
|
|
|
383 |
//ENTRY( "Test0117- SetL()", Test0117L),
|
|
|
384 |
//ENTRY( "Test0118- SetL()", Test0118L),
|
|
|
385 |
//ENTRY( "Test0119- SetL()", Test0119L),
|
|
|
386 |
//ENTRY( "Test0120- SetL()", Test0120L),
|
|
|
387 |
ENTRY( "Test0121-FindAllL()", Test0121L),
|
|
|
388 |
//ENTRY( "Test0122- FindAllL()", Test0122L),
|
|
|
389 |
//ENTRY( "Test0123- FindAllL()", Test0123L),
|
|
|
390 |
//ENTRY( "Test0124- FindAllL()", Test0124L),
|
|
|
391 |
//ENTRY( "Test0125- FindAllL()", Test0125L),
|
|
|
392 |
//ENTRY( "Test0126- FindAllL()", Test0126L),
|
|
|
393 |
//ENTRY( "Test0127- FindAllL()", Test0127L),
|
|
|
394 |
//ENTRY( "Test0128- FindAllL()", Test0128L),
|
|
|
395 |
//ENTRY( "Test0129- FindAllL()", Test0129L),
|
|
|
396 |
//ENTRY( "Test0130- FindAllL()", Test0130L),
|
|
|
397 |
//ENTRY( "Test0131- FindAllL()", Test0131L),
|
|
|
398 |
//ENTRY( "Test0132- FindAllL()", Test0132L),
|
|
|
399 |
//ENTRY( "Test0133- FindAllL()", Test0133L),
|
|
|
400 |
//ENTRY( "Test0134- FindAllL()", Test0134L),
|
|
|
401 |
//ENTRY( "Test0135- FindAllL()", Test0135L),
|
|
|
402 |
//ENTRY( "Test0136- FindAllL()", Test0136L),
|
|
|
403 |
//ENTRY( "Test0137- FindAllL()", Test0137L),
|
|
|
404 |
//ENTRY( "Test0138- FindAllL()", Test0138L),
|
|
|
405 |
//ENTRY( "Test0139- FindAllL()", Test0139L),
|
|
|
406 |
//ENTRY( "Test0140- FindAllL()", Test0140L),
|
|
|
407 |
ENTRY( "Test0141-MediaL()", Test0141L),
|
|
|
408 |
//ENTRY( "Test0142- MediaL()", Test0142L),
|
|
|
409 |
//ENTRY( "Test0143- MediaL()", Test0143L),
|
|
|
410 |
//ENTRY( "Test0144- MediaL()", Test0144L),
|
|
|
411 |
//ENTRY( "Test0145- MediaL()", Test0145L),
|
|
|
412 |
//ENTRY( "Test0146- MediaL()", Test0146L),
|
|
|
413 |
//ENTRY( "Test0147- MediaL()", Test0147L),
|
|
|
414 |
//ENTRY( "Test0148- MediaL()", Test0148L),
|
|
|
415 |
//ENTRY( "Test0149- MediaL()", Test0149L),
|
|
|
416 |
ENTRY( "Test0150-CommandL()", Test0150L),
|
|
|
417 |
//ENTRY( "Test0151- CommandL()", Test0151L),
|
|
|
418 |
//ENTRY( "Test0152- CommandL()", Test0152L),
|
|
|
419 |
//ENTRY( "Test0153- CommandL()", Test0153L),
|
|
|
420 |
//ENTRY( "Test0154- CommandL()", Test0154L),
|
|
|
421 |
//ENTRY( "Test0155- CommandL()", Test0155L),
|
|
|
422 |
//ENTRY( "Test0156- CommandL()", Test0156L),
|
|
|
423 |
//ENTRY( "Test0157- CommandL()", Test0157L),
|
|
|
424 |
//ENTRY( "Test0158- CommandL()", Test0158L),
|
|
|
425 |
//ENTRY( "Test0159- CommandL()", Test0159L),
|
|
|
426 |
//ENTRY( "Test0160- CommandL()", Test0160L),
|
|
|
427 |
//ENTRY( "Test0161- CommandL()", Test0161L),
|
|
|
428 |
//ENTRY( "Test0162- CommandL()", Test0162L),
|
|
|
429 |
//ENTRY( "Test0163- CommandL()", Test0163L),
|
|
|
430 |
//ENTRY( "Test0164- CommandL()", Test0164L),
|
|
|
431 |
//ENTRY( "Test0165- CommandL()", Test0165L),
|
|
|
432 |
//ENTRY( "Test0166- CommandL()", Test0166L),
|
|
|
433 |
//ENTRY( "Test0167- CommandL()", Test0167L),
|
|
|
434 |
//ENTRY( "Test0168- CommandL()", Test0168L),
|
|
|
435 |
//ENTRY( "Test0169- CommandL()", Test0169L),
|
|
|
436 |
ENTRY( "Test0170-CommandL()", Test0170L),
|
|
|
437 |
//ENTRY( "Test0171- CommandL()", Test0171L),
|
|
|
438 |
//ENTRY( "Test0172- CommandL()", Test0172L),
|
|
|
439 |
//ENTRY( "Test0173- CommandL()", Test0173L),
|
|
|
440 |
//ENTRY( "Test0174- CommandL()", Test0174L),
|
|
|
441 |
//ENTRY( "Test0175- CommandL()", Test0175L),
|
|
|
442 |
//ENTRY( "Test0176- CommandL()", Test0176L),
|
|
|
443 |
//ENTRY( "Test0177- CommandL()", Test0177L),
|
|
|
444 |
//ENTRY( "Test0178- CommandL()", Test0178L),
|
|
|
445 |
//ENTRY( "Test0179- CommandL()", Test0179L),
|
|
|
446 |
//ENTRY( "Test0180- CommandL()", Test0180L),
|
|
|
447 |
//ENTRY( "Test0181- CommandL()", Test0181L),
|
|
|
448 |
//ENTRY( "Test0182- CommandL()", Test0182L),
|
|
|
449 |
//ENTRY( "Test0183- CommandL()", Test0183L),
|
|
|
450 |
//ENTRY( "Test0184- CommandL()", Test0184L),
|
|
|
451 |
//ENTRY( "Test0185-GetSupportedTypesL()", Test0185L),
|
|
|
452 |
//ENTRY( "Test0186-GetSupportedTypesL()", Test0186L),
|
|
|
453 |
//ENTRY( "Test0187-GetSupportedCapabilitiesL()", Test0187L),
|
|
|
454 |
//ENTRY( "Test0188-GetSupportedCapabilitiesL()", Test0188L),
|
|
|
455 |
//ENTRY( "Test0189-GetSupportedCapabilitiesL()", Test0189L),
|
|
|
456 |
ENTRY( "Test0190-CollectionIDL()", Test0190L),
|
|
|
457 |
ENTRY( "Test0191-CollectionIDL()", Test0191L),
|
|
|
458 |
ENTRY( "Test0192-CollectionIDL()", Test0192L),
|
|
|
459 |
ENTRY( "Test0193-CollectionIDL()", Test0193L),
|
|
|
460 |
ENTRY( "Test0194-NotifyL()", Test0194L),
|
|
|
461 |
//ENTRY( "Test0195- NotifyL()", Test0195L),
|
|
|
462 |
//ENTRY( "Test0196- NotifyL()", Test0196L),
|
|
|
463 |
//ENTRY( "Test0197- NotifyL()", Test0197L),
|
|
|
464 |
//ENTRY( "Test0198- NotifyL()", Test0198L),
|
|
|
465 |
//ENTRY( "Test0199- NotifyL()", Test0199L),
|
|
|
466 |
//ENTRY( "Test0200- NotifyL()", Test0200L),
|
|
|
467 |
//ENTRY( "Test0201- NotifyL()", Test0201L),
|
|
|
468 |
//ENTRY( "Test0202- NotifyL()", Test0202L)
|
|
|
469 |
};
|
|
|
470 |
|
|
|
471 |
// Verify that case number is valid
|
|
|
472 |
if( (TUint) aCaseNumber >= sizeof( KCases ) /
|
|
|
473 |
sizeof( TCaseInfoInternal ) )
|
|
|
474 |
{
|
|
|
475 |
// Invalid case, construct empty object
|
|
|
476 |
TCaseInfo null( (const TText*) L"" );
|
|
|
477 |
null.iMethod = NULL;
|
|
|
478 |
return null;
|
|
|
479 |
}
|
|
|
480 |
|
|
|
481 |
// Construct TCaseInfo object and return it
|
|
|
482 |
TCaseInfo tmp ( KCases[ aCaseNumber ].iCaseName );
|
|
|
483 |
tmp.iMethod = KCases[ aCaseNumber ].iMethod;
|
|
|
484 |
return tmp;
|
|
|
485 |
}
|
|
|
486 |
|
|
|
487 |
// -----------------------------------------------------------------------------
|
|
|
488 |
// Initialize environment before test case
|
|
|
489 |
// -----------------------------------------------------------------------------
|
|
|
490 |
void CMpxCollectionTest::InitializeL(CActiveScheduler* scheduler)
|
|
|
491 |
{
|
|
|
492 |
iMainConsole = CConsoleMain::NewL(scheduler);
|
|
|
493 |
}
|
|
|
494 |
|
|
|
495 |
// -----------------------------------------------------------------------------
|
|
|
496 |
// Cleanup environment after test
|
|
|
497 |
// -----------------------------------------------------------------------------
|
|
|
498 |
void CMpxCollectionTest::Cleanup()
|
|
|
499 |
{
|
|
|
500 |
if(iMainConsole)
|
|
|
501 |
{
|
|
|
502 |
delete iMainConsole;
|
|
|
503 |
iMainConsole = NULL;
|
|
|
504 |
}
|
|
|
505 |
}
|
|
|
506 |
|
|
|
507 |
// ================================= TEST CASES ================================
|
|
|
508 |
|
|
|
509 |
TInt CMpxCollectionTest::CommonTestL(TInt testIndex, TTestResult& aResult)
|
|
|
510 |
{
|
|
|
511 |
__UHEAP_MARK;
|
|
|
512 |
|
|
|
513 |
InitializeL(iScheduler); //Initialize environment
|
|
|
514 |
|
|
|
515 |
// create and push
|
|
|
516 |
CCollectionTests* collectionTests = CCollectionTests::NewLC(iMainConsole,
|
|
|
517 |
NULL,
|
|
|
518 |
KTxtCollectionTests,
|
|
|
519 |
iLogger,
|
|
|
520 |
testIndex);
|
|
|
521 |
|
|
|
522 |
collectionTests->StartNextTestL();
|
|
|
523 |
|
|
|
524 |
if(!collectionTests->IsTestSynchronous(testIndex))
|
|
|
525 |
{
|
|
|
526 |
TRAPD(err, iMainConsole->ActivateL(collectionTests));
|
|
|
527 |
|
|
|
528 |
// Test passed/failed
|
|
|
529 |
if(KErrNone != err)
|
|
|
530 |
{
|
|
|
531 |
aResult.iResult = err;
|
|
|
532 |
}
|
|
|
533 |
else
|
|
|
534 |
{
|
|
|
535 |
aResult.iResult = collectionTests->GetLatestTestResult();
|
|
|
536 |
}
|
|
|
537 |
}
|
|
|
538 |
else
|
|
|
539 |
{
|
|
|
540 |
aResult.iResult = collectionTests->GetLatestTestResult();
|
|
|
541 |
}
|
|
|
542 |
|
|
|
543 |
aResult.iResultDes = KTxtCollectionTests;
|
|
|
544 |
|
|
|
545 |
CleanupStack::PopAndDestroy(collectionTests);
|
|
|
546 |
|
|
|
547 |
Cleanup(); //Cleanup environment
|
|
|
548 |
|
|
|
549 |
//iCollectionUtility may take a short time to Close()
|
|
|
550 |
User::After(1000000); // 1 second
|
|
|
551 |
|
|
|
552 |
__UHEAP_MARKEND;
|
|
|
553 |
iLogger->Log( KTxtCollectionTests);
|
|
|
554 |
|
|
|
555 |
return aResult.iResult;
|
|
|
556 |
}
|
|
|
557 |
|
|
|
558 |
// =============================== HELP FUNCTIONS ==============================
|
|
|
559 |
|
|
|
560 |
|
|
|
561 |
// ========================== OTHER EXPORTED FUNCTIONS =========================
|
|
|
562 |
|
|
|
563 |
// -----------------------------------------------------------------------------
|
|
|
564 |
// LibEntryL is a polymorphic Dll entry point
|
|
|
565 |
// Returns: CTestModuleBase*: Pointer to Test Module object
|
|
|
566 |
// -----------------------------------------------------------------------------
|
|
|
567 |
//
|
|
|
568 |
EXPORT_C CTestModuleBase* LibEntryL()
|
|
|
569 |
{
|
|
|
570 |
return CMpxCollectionTest::NewL();
|
|
|
571 |
}
|
|
|
572 |
|
|
|
573 |
// -----------------------------------------------------------------------------
|
|
|
574 |
// SetRequirements handles test module parameters(implements evolution
|
|
|
575 |
// version 1 for test module's heap and stack sizes configuring).
|
|
|
576 |
// Returns: TInt: Symbian error code.
|
|
|
577 |
// -----------------------------------------------------------------------------
|
|
|
578 |
//
|
|
|
579 |
EXPORT_C TInt SetRequirements( CTestModuleParam*& /*aTestModuleParam*/,
|
|
|
580 |
TUint32& /*aParameterValid*/ )
|
|
|
581 |
{
|
|
|
582 |
|
|
|
583 |
/* --------------------------------- NOTE ---------------------------------
|
|
|
584 |
USER PANICS occurs in test thread creation when:
|
|
|
585 |
1) "The panic occurs when the value of the stack size is negative."
|
|
|
586 |
2) "The panic occurs if the minimum heap size specified is less
|
|
|
587 |
than KMinHeapSize".
|
|
|
588 |
KMinHeapSize: "Functions that require a new heap to be allocated will
|
|
|
589 |
either panic, or will reset the required heap size to this value if
|
|
|
590 |
a smaller heap size is specified".
|
|
|
591 |
3) "The panic occurs if the minimum heap size specified is greater than
|
|
|
592 |
the maximum size to which the heap can grow".
|
|
|
593 |
Other:
|
|
|
594 |
1) Make sure that your hardware or Symbian OS is supporting given sizes.
|
|
|
595 |
e.g. Hardware might support only sizes that are divisible by four.
|
|
|
596 |
------------------------------- NOTE end ------------------------------- */
|
|
|
597 |
|
|
|
598 |
// Normally STIF uses default heap and stack sizes for test thread, see:
|
|
|
599 |
// KTestThreadMinHeap, KTestThreadMinHeap and KStackSize.
|
|
|
600 |
// If needed heap and stack sizes can be configured here by user. Remove
|
|
|
601 |
// comments and define sizes.
|
|
|
602 |
|
|
|
603 |
/*
|
|
|
604 |
aParameterValid = KStifTestModuleParameterChanged;
|
|
|
605 |
|
|
|
606 |
CTestModuleParamVer01* param = CTestModuleParamVer01::NewL();
|
|
|
607 |
// Stack size
|
|
|
608 |
param->iTestThreadStackSize= 16384; // 16K stack
|
|
|
609 |
// Heap sizes
|
|
|
610 |
param->iTestThreadMinHeap = 4096; // 4K heap min
|
|
|
611 |
param->iTestThreadMaxHeap = 1048576;// 1M heap max
|
|
|
612 |
|
|
|
613 |
aTestModuleParam = param;
|
|
|
614 |
*/
|
|
|
615 |
return KErrNone;
|
|
|
616 |
|
|
|
617 |
}
|
|
|
618 |
|
|
|
619 |
// -----------------------------------------------------------------------------
|
|
|
620 |
// E32Dll is a DLL entry point function
|
|
|
621 |
// Returns: KErrNone: No error
|
|
|
622 |
// -----------------------------------------------------------------------------
|
|
|
623 |
//
|
|
|
624 |
#ifndef EKA2
|
|
|
625 |
GLDEF_C TInt E32Dll(
|
|
|
626 |
TDllReason /*aReason*/) // Reason
|
|
|
627 |
{
|
|
|
628 |
return(KErrNone);
|
|
|
629 |
}
|
|
|
630 |
#endif
|
|
|
631 |
// End of File
|