|
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 |