|
1 /* |
|
2 * Copyright (c) 2002 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: MPXActiveTaskQueue testing implementation |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include <s32mem.h> |
|
20 #include "commontestclass.h" |
|
21 |
|
22 |
|
23 // Begin CMPXActiveTaskQueue testing implementation (mpxtaskqueue.h)======================================= |
|
24 // ----------------------------------------------------------------------------- |
|
25 // CCommonTestClass::CreateCMPXActiveTaskQueueL() |
|
26 // Returns: Symbian OS errors. |
|
27 // ----------------------------------------------------------------------------- |
|
28 TInt CCommonTestClass::CreateCMPXActiveTaskQueueL() |
|
29 { |
|
30 FTRACE(FPrint(_L("CCommonTestClass::CreateCMPXActiveTaskQueueL testing CMPXActiveTaskQueue::NewL() begin"))); |
|
31 iLog->Log(_L("CCommonTestClass::CreateCMPXActiveTaskQueueL testing CMPXActiveTaskQueue::NewL() begin")); |
|
32 TInt err = KErrNone; |
|
33 CMPXActiveTaskQueue* taskQueue = NULL; |
|
34 taskQueue = CMPXActiveTaskQueue::NewL(); |
|
35 if ( taskQueue == NULL) |
|
36 { |
|
37 err = KErrNotFound; |
|
38 } |
|
39 delete taskQueue; |
|
40 FTRACE(FPrint(_L("CCommonTestClass::CreateCMPXActiveTaskQueueL testing CMPXActiveTaskQueue::NewL() end err=%d"), err)); |
|
41 iLog->Log(_L("CCommonTestClass::CreateCMPXActiveTaskQueueL testing CMPXActiveTaskQueue::NewL() end err=%d"), err); |
|
42 return err; |
|
43 } |
|
44 |
|
45 |
|
46 // ----------------------------------------------------------------------------- |
|
47 // CCommonTestClass::CancelRequestsCMPXActiveTaskQueueL() |
|
48 // Returns: Symbian OS errors. |
|
49 // ----------------------------------------------------------------------------- |
|
50 TInt CCommonTestClass::CancelRequestsCMPXActiveTaskQueueL() |
|
51 { |
|
52 FTRACE(FPrint(_L("CCommonTestClass::CancelRequestsCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CancelRequests begin"))); |
|
53 iLog->Log(_L("CCommonTestClass::CancelRequestsCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CancelRequests begin")); |
|
54 TInt err = KErrNone; |
|
55 CMPXActiveTaskQueue* taskQueue = NULL; |
|
56 taskQueue = CMPXActiveTaskQueue::NewL(); |
|
57 taskQueue->CancelRequests(); |
|
58 delete taskQueue; |
|
59 FTRACE(FPrint(_L("CCommonTestClass::CancelRequestsCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CancelRequests end=%d"), err)); |
|
60 iLog->Log(_L("CCommonTestClass::CancelRequestsCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CancelRequests end=%d"), err); |
|
61 return err; |
|
62 } |
|
63 |
|
64 |
|
65 // ----------------------------------------------------------------------------- |
|
66 // CCommonTestClass::AddTaskCMPXActiveTaskQueueL() |
|
67 // Returns: Symbian OS errors. |
|
68 // ----------------------------------------------------------------------------- |
|
69 TInt CCommonTestClass::AddTaskCMPXActiveTaskQueueL() |
|
70 { |
|
71 FTRACE(FPrint(_L("CCommonTestClass::AddTaskCMPXActiveTaskQueueL testing CMPXActiveTaskQueue::AddTaskL begin"))); |
|
72 iLog->Log(_L("CCommonTestClass::AddTaskCMPXActiveTaskQueueL testing CMPXActiveTaskQueue::AddTaskL begin")); |
|
73 TInt err = KErrNone; |
|
74 |
|
75 CMPXActiveTaskQueue* taskQueue = NULL; |
|
76 taskQueue = CMPXActiveTaskQueue::NewL(); |
|
77 |
|
78 TInt task(0); //ETaskNone |
|
79 CBufBase* taskParam(NULL); |
|
80 taskQueue->AddTaskL( task, |
|
81 NULL, // callback when task completed |
|
82 NULL, // task queue observer |
|
83 0, // Integer paramter, not used |
|
84 taskParam, // task queue assumes ownership of taskParam |
|
85 NULL, // Ptr data |
|
86 NULL ); |
|
87 taskQueue->CancelRequests(); |
|
88 delete taskQueue; |
|
89 |
|
90 FTRACE(FPrint(_L("CCommonTestClass::AddTaskCMPXActiveTaskQueueL testing CMPXActiveTaskQueue::AddTaskL end err=%d"), err)); |
|
91 iLog->Log(_L("CCommonTestClass::AddTaskCMPXActiveTaskQueueL testing CMPXActiveTaskQueue::AddTaskL end err=%d"), err); |
|
92 return err; |
|
93 } |
|
94 |
|
95 |
|
96 // ----------------------------------------------------------------------------- |
|
97 // CCommonTestClass::CompleteTaskCMPXActiveTaskQueueL() |
|
98 // Returns: Symbian OS errors. |
|
99 // ----------------------------------------------------------------------------- |
|
100 TInt CCommonTestClass::CompleteTaskCMPXActiveTaskQueueL() |
|
101 { |
|
102 FTRACE(FPrint(_L("CCommonTestClass::CompleteTaskCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CompleteTask begin"))); |
|
103 iLog->Log(_L("CCommonTestClass::CompleteTaskCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CompleteTask begin")); |
|
104 TInt err = KErrNone; |
|
105 CMPXActiveTaskQueue* taskQueue = NULL; |
|
106 taskQueue = CMPXActiveTaskQueue::NewL(); |
|
107 TInt task(0); //ETaskNone |
|
108 CBufBase* taskParam(NULL); |
|
109 taskQueue->AddTaskL( task, |
|
110 NULL, // callback when task completed |
|
111 NULL, // task queue observer |
|
112 0, // Integer paramter, not used |
|
113 taskParam, // task queue assumes ownership of taskParam |
|
114 NULL, // Ptr data |
|
115 NULL ); |
|
116 taskQueue->CompleteTask(); |
|
117 taskQueue->CancelRequests(); |
|
118 delete taskQueue; |
|
119 FTRACE(FPrint(_L("CCommonTestClass::CompleteTaskCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CompleteTask end=%d"), err)); |
|
120 iLog->Log(_L("CCommonTestClass::CompleteTaskCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CompleteTask end=%d"), err); |
|
121 return err; |
|
122 } |
|
123 |
|
124 // ----------------------------------------------------------------------------- |
|
125 // CCommonTestClass::CompleteAllTasksCMPXActiveTaskQueueL() |
|
126 // Returns: Symbian OS errors. |
|
127 // ----------------------------------------------------------------------------- |
|
128 TInt CCommonTestClass::CompleteAllTasksCMPXActiveTaskQueueL() |
|
129 { |
|
130 FTRACE(FPrint(_L("CCommonTestClass::CompleteAllTasksCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CompleteTask begin"))); |
|
131 iLog->Log(_L("CCommonTestClass::CompleteAllTasksCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CompleteTask begin")); |
|
132 TInt err = KErrNone; |
|
133 CMPXActiveTaskQueue* taskQueue = NULL; |
|
134 taskQueue = CMPXActiveTaskQueue::NewL(); |
|
135 TInt task(0); //ETaskNone |
|
136 CBufBase* taskParam(NULL); |
|
137 taskQueue->AddTaskL( task, |
|
138 NULL, // callback when task completed |
|
139 NULL, // task queue observer |
|
140 0, // Integer paramter, not used |
|
141 taskParam, // task queue assumes ownership of taskParam |
|
142 NULL, // Ptr data |
|
143 NULL ); |
|
144 taskQueue->CompleteTask(); |
|
145 taskQueue->CompleteAllTasks( 0 ); |
|
146 taskQueue->CancelRequests(); |
|
147 delete taskQueue; |
|
148 FTRACE(FPrint(_L("CCommonTestClass::CompleteAllTasksCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CompleteTask end=%d"), err)); |
|
149 iLog->Log(_L("CCommonTestClass::CompleteAllTasksCMPXActiveTaskQueueL testing CMPXActiveTaskQueueL::CompleteTask end=%d"), err); |
|
150 return err; |
|
151 } |
|
152 |
|
153 // ----------------------------------------------------------------------------- |
|
154 // CCommonTestClass::IsEmptyCMPXTaskQueueL() |
|
155 // Returns: Symbian OS errors. |
|
156 // ----------------------------------------------------------------------------- |
|
157 TInt CCommonTestClass::IsEmptyCMPXTaskQueueL() |
|
158 { |
|
159 FTRACE(FPrint(_L("CCommonTestClass::IsEmptyCMPXTaskQueueL testing CMPXTaskQueueL::IsEmpty begin"))); |
|
160 iLog->Log(_L("CCommonTestClass::IsEmptyCMPXTaskQueueL testing CMPXTaskQueueL::IsEmpty begin")); |
|
161 TInt err = KErrNone; |
|
162 CMPXTaskQueue* taskQueue = NULL; |
|
163 taskQueue = CMPXTaskQueue::NewL(); |
|
164 taskQueue->IsEmpty(); |
|
165 delete taskQueue; |
|
166 FTRACE(FPrint(_L("CCommonTestClass::IsEmptyCMPXTaskQueueL testing CMPXTaskQueueL::IsEmpty end=%d"), err)); |
|
167 iLog->Log(_L("CCommonTestClass::IsEmptyCMPXTaskQueueL testing CMPXTaskQueueL::IsEmpty end=%d"), err); |
|
168 return err; |
|
169 } |
|
170 |
|
171 |
|
172 // ----------------------------------------------------------------------------- |
|
173 // CCommonTestClass::AddTaskCMPXTaskQueueL() |
|
174 // Returns: Symbian OS errors. |
|
175 // ----------------------------------------------------------------------------- |
|
176 TInt CCommonTestClass::AddTaskCMPXTaskQueueL() |
|
177 { |
|
178 FTRACE(FPrint(_L("CCommonTestClass::AddTaskCMPXTaskQueueL testing CMPXTaskQueue::AddTaskL begin"))); |
|
179 iLog->Log(_L("CCommonTestClass::AddTaskCMPXTaskQueueL testing CMPXTaskQueue::AddTaskL begin")); |
|
180 TInt err = KErrNone; |
|
181 |
|
182 CMPXTaskQueue* taskQueue = CMPXTaskQueue::NewL(); |
|
183 TInt task(0); //ETaskNone |
|
184 CBufBase* taskParam(NULL); |
|
185 taskQueue->AddTaskL( task, |
|
186 NULL, // callback when task completed |
|
187 NULL, // task queue observer |
|
188 0, // Integer paramter, not used |
|
189 taskParam, // task queue assumes ownership of taskParam |
|
190 NULL, // Ptr data |
|
191 NULL ); |
|
192 taskQueue->Reset(); |
|
193 delete taskQueue; |
|
194 |
|
195 FTRACE(FPrint(_L("CCommonTestClass::AddTaskCMPXTaskQueueL testing CMPXTaskQueue::AddTaskL end err=%d"), err)); |
|
196 iLog->Log(_L("CCommonTestClass::AddTaskCMPXTaskQueueL testing CMPXTaskQueue::AddTaskL end err=%d"), err); |
|
197 return err; |
|
198 } |
|
199 |
|
200 |
|
201 // ----------------------------------------------------------------------------- |
|
202 // CCommonTestClass::RemoveTaskCMPXTaskQueueL() |
|
203 // Returns: Symbian OS errors. |
|
204 // ----------------------------------------------------------------------------- |
|
205 TInt CCommonTestClass::RemoveTaskCMPXTaskQueueL() |
|
206 { |
|
207 FTRACE(FPrint(_L("CCommonTestClass::RemoveTaskCMPXTaskQueueL testing CMPXTaskQueue::RemoveTask begin"))); |
|
208 iLog->Log(_L("CCommonTestClass::RemoveTaskCMPXTaskQueueL testing CMPXTaskQueue::RemoveTask begin")); |
|
209 TInt err = KErrNone; |
|
210 |
|
211 CMPXTaskQueue* taskQueue = CMPXTaskQueue::NewL(); |
|
212 TInt task(0); //ETaskNone |
|
213 CBufBase* taskParam(NULL); |
|
214 taskQueue->AddTaskL( task, |
|
215 this, // task queue observer |
|
216 0, // Integer paramter, not used |
|
217 taskParam, // task queue assumes ownership of taskParam |
|
218 NULL, // Ptr data |
|
219 NULL, |
|
220 NULL ); |
|
221 |
|
222 taskQueue->RemoveTask(this); |
|
223 delete taskQueue; |
|
224 |
|
225 FTRACE(FPrint(_L("CCommonTestClass::RemoveTaskCMPXTaskQueueL testing CMPXTaskQueue::RemoveTask end err=%d"), err)); |
|
226 iLog->Log(_L("CCommonTestClass::RemoveTaskCMPXTaskQueueL testing CMPXTaskQueue::RemoveTask end err=%d"), err); |
|
227 return err; |
|
228 } |
|
229 |
|
230 |
|
231 // ----------------------------------------------------------------------------- |
|
232 // CCommonTestClass::CallbackCMPXTaskQueueL() |
|
233 // Returns: Symbian OS errors. |
|
234 // ----------------------------------------------------------------------------- |
|
235 TInt CCommonTestClass::CallbackCMPXTaskQueueL() |
|
236 { |
|
237 FTRACE(FPrint(_L("CCommonTestClass::CallbackCMPXTaskQueueL testing CMPXTaskQueue::Callback begin"))); |
|
238 iLog->Log(_L("CCommonTestClass::CallbackCMPXTaskQueueL testing CMPXTaskQueue::Callback begin")); |
|
239 TInt err = KErrNone; |
|
240 |
|
241 CMPXTaskQueue* taskQueue = CMPXTaskQueue::NewL(); |
|
242 TInt task(0); //ETaskNone |
|
243 CBufBase* taskParam(NULL); |
|
244 taskQueue->AddTaskL( task, |
|
245 this, // task queue observer |
|
246 0, // Integer paramter, not used |
|
247 taskParam, // task queue assumes ownership of taskParam |
|
248 NULL, // Ptr data |
|
249 NULL, |
|
250 NULL ); |
|
251 |
|
252 taskQueue->Callback(); |
|
253 taskQueue->RemoveTask(this); |
|
254 delete taskQueue; |
|
255 |
|
256 FTRACE(FPrint(_L("CCommonTestClass::CallbackCMPXTaskQueueL testing CMPXTaskQueue::Callback end err=%d"), err)); |
|
257 iLog->Log(_L("CCommonTestClass::CallbackCMPXTaskQueueL testing CMPXTaskQueue::Callback end err=%d"), err); |
|
258 return err; |
|
259 } |
|
260 |
|
261 |
|
262 // ----------------------------------------------------------------------------- |
|
263 // CCommonTestClass::ParamCMPXTaskQueueL() |
|
264 // Returns: Symbian OS errors. |
|
265 // ----------------------------------------------------------------------------- |
|
266 TInt CCommonTestClass::ParamCMPXTaskQueueL() |
|
267 { |
|
268 FTRACE(FPrint(_L("CCommonTestClass::ParamCMPXTaskQueueL testing CMPXTaskQueue::Param begin"))); |
|
269 iLog->Log(_L("CCommonTestClass::ParamCMPXTaskQueueL testing CMPXTaskQueue::Param begin")); |
|
270 TInt err = KErrNone; |
|
271 |
|
272 CMPXTaskQueue* taskQueue = CMPXTaskQueue::NewL(); |
|
273 TInt task(0); //ETaskNone |
|
274 CBufBase* taskParam(NULL); |
|
275 taskQueue->AddTaskL( task, |
|
276 this, // task queue observer |
|
277 0, // Integer paramter, not used |
|
278 taskParam, // task queue assumes ownership of taskParam |
|
279 NULL, // Ptr data |
|
280 NULL, |
|
281 NULL ); |
|
282 |
|
283 taskQueue->Param(); |
|
284 taskQueue->RemoveTask(this); |
|
285 delete taskQueue; |
|
286 |
|
287 FTRACE(FPrint(_L("CCommonTestClass::ParamCMPXTaskQueueL testing CMPXTaskQueue::Param end err=%d"), err)); |
|
288 iLog->Log(_L("CCommonTestClass::ParamCMPXTaskQueueL testing CMPXTaskQueue::Param end err=%d"), err); |
|
289 return err; |
|
290 } |
|
291 |
|
292 |
|
293 // ----------------------------------------------------------------------------- |
|
294 // CCommonTestClass::PtrDataCMPXTaskQueueL() |
|
295 // Returns: Symbian OS errors. |
|
296 // ----------------------------------------------------------------------------- |
|
297 TInt CCommonTestClass::PtrDataCMPXTaskQueueL() |
|
298 { |
|
299 FTRACE(FPrint(_L("CCommonTestClass::ParamCMPXTaskQueueL testing CMPXTaskQueue::PtrData begin"))); |
|
300 iLog->Log(_L("CCommonTestClass::ParamCMPXTaskQueueL testing CMPXTaskQueue::PtrData begin")); |
|
301 TInt err = KErrNone; |
|
302 |
|
303 CMPXTaskQueue* taskQueue = CMPXTaskQueue::NewL(); |
|
304 TInt task(0); //ETaskNone |
|
305 CBufBase* taskParam(NULL); |
|
306 taskQueue->AddTaskL( task, |
|
307 this, // task queue observer |
|
308 0, // Integer paramter, not used |
|
309 taskParam, // task queue assumes ownership of taskParam |
|
310 NULL, // Ptr data |
|
311 NULL, |
|
312 NULL ); |
|
313 |
|
314 taskQueue->PtrData(); |
|
315 taskQueue->RemoveTask(this); |
|
316 delete taskQueue; |
|
317 |
|
318 FTRACE(FPrint(_L("CCommonTestClass::ParamCMPXTaskQueueL testing CMPXTaskQueue::PtrData end err=%d"), err)); |
|
319 iLog->Log(_L("CCommonTestClass::ParamCMPXTaskQueueL testing CMPXTaskQueue::PtrData end err=%d"), err); |
|
320 return err; |
|
321 } |
|
322 |
|
323 // ----------------------------------------------------------------------------- |
|
324 // CCommonTestClass::BufDataCMPXTaskQueueL() |
|
325 // Returns: Symbian OS errors. |
|
326 // ----------------------------------------------------------------------------- |
|
327 TInt CCommonTestClass::BufDataCMPXTaskQueueL() |
|
328 { |
|
329 FTRACE(FPrint(_L("CCommonTestClass::BufDataCMPXTaskQueueL testing CMPXTaskQueue::BufData begin"))); |
|
330 iLog->Log(_L("CCommonTestClass::BufDataCMPXTaskQueueL testing CMPXTaskQueue::BufData begin")); |
|
331 TInt err = KErrNone; |
|
332 |
|
333 CMPXTaskQueue* taskQueue = CMPXTaskQueue::NewL(); |
|
334 TInt task(0); //ETaskNone |
|
335 CBufBase* taskParam(NULL); |
|
336 taskQueue->AddTaskL( task, |
|
337 this, // task queue observer |
|
338 0, // Integer paramter, not used |
|
339 taskParam, // task queue assumes ownership of taskParam |
|
340 NULL, // Ptr data |
|
341 NULL, |
|
342 NULL ); |
|
343 |
|
344 taskQueue->BufData(); |
|
345 taskQueue->RemoveTask(this); |
|
346 delete taskQueue; |
|
347 |
|
348 FTRACE(FPrint(_L("CCommonTestClass::BufDataCMPXTaskQueueL testing CMPXTaskQueue::BufData end err=%d"), err)); |
|
349 iLog->Log(_L("CCommonTestClass::BufDataCMPXTaskQueueL testing CMPXTaskQueue::BufData end err=%d"), err); |
|
350 return err; |
|
351 } |
|
352 |
|
353 |
|
354 // ----------------------------------------------------------------------------- |
|
355 // CCommonTestClass::RemoveTask2CMPXTaskQueueL() |
|
356 // Returns: Symbian OS errors. |
|
357 // ----------------------------------------------------------------------------- |
|
358 TInt CCommonTestClass::RemoveTask2CMPXTaskQueueL() |
|
359 { |
|
360 FTRACE(FPrint(_L("CCommonTestClass::RemoveTask2CMPXTaskQueueL testing CMPXTaskQueue::RemoveTask begin"))); |
|
361 iLog->Log(_L("CCommonTestClass::RemoveTask2CMPXTaskQueueL testing CMPXTaskQueue::RemoveTask begin")); |
|
362 TInt err = KErrNone; |
|
363 |
|
364 CMPXTaskQueue* taskQueue = CMPXTaskQueue::NewL(); |
|
365 TInt task(0); //ETaskNone |
|
366 CBufBase* taskParam(NULL); |
|
367 taskQueue->AddTaskL( task, |
|
368 this, // task queue observer |
|
369 0, // Integer paramter, not used |
|
370 taskParam, // task queue assumes ownership of taskParam |
|
371 NULL, // Ptr data |
|
372 NULL, |
|
373 NULL ); |
|
374 |
|
375 taskQueue->RemoveTask(); |
|
376 delete taskQueue; |
|
377 |
|
378 FTRACE(FPrint(_L("CCommonTestClass::RemoveTask2CMPXTaskQueueL testing CMPXTaskQueue::RemoveTask end err=%d"), err)); |
|
379 iLog->Log(_L("CCommonTestClass::RemoveTask2CMPXTaskQueueL testing CMPXTaskQueue::RemoveTask end err=%d"), err); |
|
380 return err; |
|
381 } |
|
382 |
|
383 |
|
384 // ----------------------------------------------------------------------------- |
|
385 // CCommonTestClass::TaskCMPXTaskQueueL() |
|
386 // Returns: Symbian OS errors. |
|
387 // ----------------------------------------------------------------------------- |
|
388 TInt CCommonTestClass::TaskCMPXTaskQueueL() |
|
389 { |
|
390 FTRACE(FPrint(_L("CCommonTestClass::TaskCMPXTaskQueueL testing CMPXTaskQueue::Task begin"))); |
|
391 iLog->Log(_L("CCommonTestClass::TaskCMPXTaskQueueL testing CMPXTaskQueue::Task begin")); |
|
392 TInt err = KErrNone; |
|
393 |
|
394 CMPXTaskQueue* taskQueue = CMPXTaskQueue::NewL(); |
|
395 TInt task(0); //ETaskNone |
|
396 CBufBase* taskParam(NULL); |
|
397 taskQueue->AddTaskL( task, |
|
398 this, // task queue observer |
|
399 0, // Integer paramter, not used |
|
400 taskParam, // task queue assumes ownership of taskParam |
|
401 NULL, // Ptr data |
|
402 NULL, |
|
403 NULL ); |
|
404 |
|
405 taskQueue->Task(); |
|
406 delete taskQueue; |
|
407 |
|
408 FTRACE(FPrint(_L("CCommonTestClass::TaskCMPXTaskQueueL testing CMPXTaskQueue::Task end err=%d"), err)); |
|
409 iLog->Log(_L("CCommonTestClass::TaskCMPXTaskQueueL testing CMPXTaskQueue::Task end err=%d"), err); |
|
410 return err; |
|
411 } |
|
412 void CCommonTestClass::ExecuteTask(TInt /*aTask*/, TInt /*aParamData*/, |
|
413 TAny* /*aPtrData*/, |
|
414 const CBufBase& /*aBuf*/, |
|
415 TAny* /*aCallback*/, |
|
416 CBase* /*aCObject1*/, |
|
417 CBase* /*aCObject2*/) |
|
418 { |
|
419 FTRACE(FPrint(_L("CCommonTestClass::ExecuteTask is called"))); |
|
420 iLog->Log(_L("CCommonTestClass::ExecuteTask is called")); |
|
421 } |
|
422 //----------------------------------------------------------------------------- |
|
423 // CCommonTestClass::CreateCMPXTaskQueue() |
|
424 // Returns: Symbian OS errors. |
|
425 // add CreateCMPXTaskQueue to testmpxactivetaskqueue.cpp |
|
426 //----------------------------------------------------------------------------- |
|
427 |
|
428 TInt CCommonTestClass::CreateCMPXTaskQueue() |
|
429 { |
|
430 FTRACE(FPrint(_L("CCommonTestClass::CreateCMPXTaskQueue testing CMPXTaskQueue::NewL() begin"))); |
|
431 iLog->Log(_L("CCommonTestClass::CreateCMPXTaskQueue testing CMPXTaskQueue::NewL() begin")); |
|
432 TInt err = KErrNone; |
|
433 CMPXTaskQueue* taskQueue = NULL; |
|
434 TRAP(err, taskQueue = CMPXTaskQueue::NewL()); |
|
435 if ( taskQueue == NULL) |
|
436 { |
|
437 err = KErrNotFound; |
|
438 } |
|
439 delete taskQueue; |
|
440 FTRACE(FPrint(_L("CCommonTestClass::CreateCMPXTaskQueue testing CMPXTaskQueue::NewL() end err=%d"), err)); |
|
441 iLog->Log(_L("CCommonTestClass::CreateCMPXTaskQueue testing CMPXTaskQueue::NewL() end err=%d"), err); |
|
442 return err; |
|
443 } |
|
444 //----------------------------------------------------------------------------- |
|
445 // CCommonTestClass::DeleteCMPXTaskQueue() |
|
446 // Returns: Symbian OS errors. |
|
447 // add CreateCMPXTaskQueue to testmpxactivetaskqueue.cpp |
|
448 //----------------------------------------------------------------------------- |
|
449 TInt CCommonTestClass::DeleteCMPXTaskQueue() |
|
450 { |
|
451 FTRACE(FPrint(_L("CCommonTestClass::DeleteCMPXTaskQueue testing CMPXTaskQueue::~ begin"))); |
|
452 iLog->Log(_L("CCommonTestClass::DeleteCMPXTaskQueue testing CMPXTaskQueue::~ begin")); |
|
453 TInt err = KErrNone; |
|
454 CMPXTaskQueue* taskQueue = NULL; |
|
455 TRAP(err , taskQueue = CMPXTaskQueue::NewL()); |
|
456 delete taskQueue; |
|
457 taskQueue=NULL; |
|
458 FTRACE(FPrint(_L("CCommonTestClass::DeleteCMPXTaskQueue testing CMPXTaskQueue::~ end err=%d"), err)); |
|
459 iLog->Log(_L("CCommonTestClass::DeleteCMPXTaskQueue testing CMPXTaskQueue::~ end err=%d"), err); |
|
460 return err; |
|
461 } |
|
462 //----------------------------------------------------------------------------- |
|
463 // CCommonTestClass::ScheduleNextTaskCMPXTaskQueue() |
|
464 // Returns: Symbian OS errors. |
|
465 // add ScheduleNextTaskCMPXTaskQueue to testmpxactivetaskqueue.cpp |
|
466 //----------------------------------------------------------------------------- |
|
467 TInt CCommonTestClass::ScheduleNextTaskCMPXTaskQueue() |
|
468 { |
|
469 FTRACE(FPrint(_L("CCommonTestClass::ScheduleNextTaskCMPXTaskQueue testing CMPXTaskQueue::ScheduleNextTask begin"))); |
|
470 iLog->Log(_L("CCommonTestClass::ScheduleNextTaskCMPXTaskQueue testing CMPXTaskQueue::ScheduleNextTask begin")); |
|
471 TInt err = KErrNone; |
|
472 CMPXActiveTaskQueue* taskQueue = NULL; |
|
473 TRAP(err , taskQueue = CMPXActiveTaskQueue::NewL()); |
|
474 taskQueue->ScheduleNextTask(); |
|
475 delete taskQueue; |
|
476 FTRACE(FPrint(_L("CCommonTestClass::ScheduleNextTaskCMPXTaskQueue testing CMPXTaskQueue::ScheduleNextTask end err=%d"), err)); |
|
477 iLog->Log(_L("CCommonTestClass::ScheduleNextTaskCMPXTaskQueue testing CMPXTaskQueue::ScheduleNextTask end err=%d"), err); |
|
478 return err; |
|
479 } |
|
480 //----------------------------------------------------------------------------- |
|
481 // CCommonTestClass::ResetCMPXTaskQueue() |
|
482 // Returns: Symbian OS errors. |
|
483 // add ResetCMPXTaskQueue to testmpxactivetaskqueue.cpp |
|
484 //----------------------------------------------------------------------------- |
|
485 TInt CCommonTestClass::ResetCMPXTaskQueue() |
|
486 { |
|
487 FTRACE(FPrint(_L("CCommonTestClass::ResetCMPXTaskQueue testing CMPXTaskQueue::Reset begin"))); |
|
488 iLog->Log(_L("CCommonTestClass::ResetCMPXTaskQueue testing CMPXTaskQueue::Reset begin")); |
|
489 TInt err = KErrNone; |
|
490 CMPXTaskQueue* taskQueue = NULL; |
|
491 TRAP(err , taskQueue = CMPXTaskQueue::NewL()); |
|
492 TInt task(0); //ETaskNone |
|
493 CBufBase* taskParam(NULL); |
|
494 TRAP(err, taskQueue->AddTaskL( task, |
|
495 NULL, // callback when task completed |
|
496 NULL, // task queue observer |
|
497 0, // Integer paramter, not used |
|
498 taskParam, // task queue assumes ownership of taskParam |
|
499 NULL, // Ptr data |
|
500 NULL )); |
|
501 taskQueue->Reset(); |
|
502 delete taskQueue; |
|
503 FTRACE(FPrint(_L("CCommonTestClass::ResetCMPXTaskQueue testing CMPXTaskQueue::Reset end err=%d"), err)); |
|
504 iLog->Log(_L("CCommonTestClass::ResetCMPXTaskQueue testing CMPXTaskQueue::Reset end err=%d"), err); |
|
505 return err; |
|
506 } |
|
507 //----------------------------------------------------------------------------- |
|
508 // CCommonTestClass::DeleteCMPXActiveTaskQueue() |
|
509 // Returns: Symbian OS errors. |
|
510 // add DeleteCMPXActiveTaskQueue to testmpxactivetaskqueue.cpp |
|
511 //----------------------------------------------------------------------------- |
|
512 |
|
513 TInt CCommonTestClass::DeleteCMPXActiveTaskQueue() |
|
514 { |
|
515 FTRACE(FPrint(_L("CCommonTestClass::DeleteCMPXActiveTaskQueue testing CMPXTaskQueue::~CMPXActiveTaskQueue begin"))); |
|
516 iLog->Log(_L("CCommonTestClass::DeleteCMPXActiveTaskQueue testing CMPXTaskQueue::~CMPXActiveTaskQueue begin")); |
|
517 TInt err = KErrNone; |
|
518 CMPXActiveTaskQueue* taskQueue = NULL; |
|
519 TRAP(err , taskQueue = CMPXActiveTaskQueue::NewL()); |
|
520 delete taskQueue; |
|
521 taskQueue=NULL; |
|
522 FTRACE(FPrint(_L("CCommonTestClass::DeleteCMPXActiveTaskQueue testing CMPXTaskQueue::~CMPXActiveTaskQueue end err=%d"), err)); |
|
523 iLog->Log(_L("CCommonTestClass::DeleteCMPXActiveTaskQueue testing CMPXTaskQueue::~CMPXActiveTaskQueue end err=%d"), err); |
|
524 return err; |
|
525 } |
|
526 |