1 /* |
|
2 * Copyright (c) 2009 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: |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 // INTERNAL INCLUDES |
|
20 #include "ut_musengcamerahandler.h" |
|
21 #include "musengstubs.h" |
|
22 #include "musengtestdefs.h" |
|
23 #include "musenglivesession.h" |
|
24 #include "mussipprofilehandler.h" |
|
25 #include "musengmceutils.h" |
|
26 #include "mussettings.h" |
|
27 #include "mussessionproperties.h" |
|
28 |
|
29 // SYSTEM INCLUDES |
|
30 #include <eunitmacros.h> |
|
31 #include <mceoutsession.h> |
|
32 #include <mcestreambundle.h> |
|
33 #include <mcevideostream.h> |
|
34 #include <mcecamerasource.h> |
|
35 #include <mcertpsink.h> |
|
36 #include <mcedisplaysink.h> |
|
37 #include <mcertpsource.h> |
|
38 |
|
39 const TUint KSipProfileId( 1 ); |
|
40 |
|
41 //use step in different time period |
|
42 const TInt KZoomBigStepCount = 15; |
|
43 const TInt KZoomSmallStepCount = KZoomBigStepCount*2; |
|
44 const TInt KZoomStepMinSize = 1; |
|
45 |
|
46 // 0.4 second |
|
47 const TInt64 KZoomFasterTime = 400000;//must bigger than 1/3 second |
|
48 |
|
49 //insure that step is 1 |
|
50 #define USER_SLEEP User::After(KZoomFasterTime) |
|
51 |
|
52 |
|
53 |
|
54 // ----------------------------------------------------------------------------- |
|
55 // |
|
56 // ----------------------------------------------------------------------------- |
|
57 // |
|
58 UT_TMusEngCameraHandler* UT_TMusEngCameraHandler::NewL() |
|
59 { |
|
60 UT_TMusEngCameraHandler* self = UT_TMusEngCameraHandler::NewLC(); |
|
61 CleanupStack::Pop( self ); |
|
62 return self; |
|
63 } |
|
64 |
|
65 |
|
66 // ----------------------------------------------------------------------------- |
|
67 // |
|
68 // ----------------------------------------------------------------------------- |
|
69 // |
|
70 UT_TMusEngCameraHandler* UT_TMusEngCameraHandler::NewLC() |
|
71 { |
|
72 UT_TMusEngCameraHandler* self = new( ELeave ) UT_TMusEngCameraHandler(); |
|
73 CleanupStack::PushL( self ); |
|
74 self->ConstructL(); |
|
75 return self; |
|
76 } |
|
77 |
|
78 |
|
79 // ----------------------------------------------------------------------------- |
|
80 // |
|
81 // ----------------------------------------------------------------------------- |
|
82 // |
|
83 UT_TMusEngCameraHandler::~UT_TMusEngCameraHandler() |
|
84 { |
|
85 // NOP |
|
86 } |
|
87 |
|
88 |
|
89 // ----------------------------------------------------------------------------- |
|
90 // Default constructor |
|
91 // ----------------------------------------------------------------------------- |
|
92 // |
|
93 UT_TMusEngCameraHandler::UT_TMusEngCameraHandler() |
|
94 { |
|
95 // NOP |
|
96 } |
|
97 |
|
98 |
|
99 // ----------------------------------------------------------------------------- |
|
100 // Second phase construct |
|
101 // ----------------------------------------------------------------------------- |
|
102 // |
|
103 void UT_TMusEngCameraHandler::ConstructL() |
|
104 { |
|
105 // The ConstructL from the base class CEUnitTestSuiteClass must be called. |
|
106 // It generates the test case table. |
|
107 CEUnitTestSuiteClass::ConstructL(); |
|
108 } |
|
109 |
|
110 |
|
111 // ----------------------------------------------------------------------------- |
|
112 // |
|
113 // ----------------------------------------------------------------------------- |
|
114 // |
|
115 void UT_TMusEngCameraHandler::SetupL() |
|
116 { |
|
117 iManager = CMceManager::NewL( TUid::Null(), NULL ); |
|
118 iObserver = new( ELeave ) CMusEngObserverStub; |
|
119 iObserver->iRoamingBetweenAPsAllowed = ETrue; |
|
120 iProfileHandler = CMusSipProfileHandler::NewL( *iObserver ); |
|
121 |
|
122 iProfileHandler->CreateProfileL( KSipProfileId ); |
|
123 |
|
124 iSession = CMceOutSession::NewL( *iManager, |
|
125 *iProfileHandler->Profile(), |
|
126 KTestRecipientSipUri8() ); |
|
127 |
|
128 |
|
129 CMceVideoStream* videoOut = CMceVideoStream::NewLC(); |
|
130 |
|
131 videoOut->AddSinkL( CMceRtpSink::NewLC() ); |
|
132 CleanupStack::Pop(); |
|
133 |
|
134 videoOut->AddSinkL( CMceDisplaySink::NewLC( *iManager ) ); |
|
135 CleanupStack::Pop(); |
|
136 |
|
137 videoOut->SetSourceL( CMceCameraSource::NewLC( *iManager ) ); |
|
138 CleanupStack::Pop(); |
|
139 |
|
140 CMceVideoStream* videoIn = CMceVideoStream::NewLC(); |
|
141 |
|
142 CMceDisplaySink* receivingDisplay = CMceDisplaySink::NewLC( *iManager ); |
|
143 videoIn->AddSinkL( receivingDisplay ); |
|
144 CleanupStack::Pop(); |
|
145 |
|
146 videoIn->SetSourceL( CMceRtpSource::NewLC() ); |
|
147 CleanupStack::Pop(); |
|
148 |
|
149 videoOut->BindL( videoIn ); |
|
150 CleanupStack::Pop( videoIn ); |
|
151 |
|
152 iSession->AddStreamL( videoOut ); |
|
153 CleanupStack::Pop( videoOut ); |
|
154 } |
|
155 |
|
156 // ----------------------------------------------------------------------------- |
|
157 // |
|
158 // ----------------------------------------------------------------------------- |
|
159 // |
|
160 void UT_TMusEngCameraHandler::Teardown() |
|
161 { |
|
162 delete iSession; |
|
163 iSession = NULL; |
|
164 iCameraHandler.SetSession( NULL ); |
|
165 delete iProfileHandler; |
|
166 delete iObserver; |
|
167 delete iManager; |
|
168 } |
|
169 |
|
170 |
|
171 |
|
172 // TEST CASES |
|
173 |
|
174 // ----------------------------------------------------------------------------- |
|
175 // |
|
176 // ----------------------------------------------------------------------------- |
|
177 // |
|
178 void UT_TMusEngCameraHandler::UT_LcCameraCountL() |
|
179 { |
|
180 // Call without setting the MCE session |
|
181 EUNIT_ASSERT_SPECIFIC_LEAVE( iCameraHandler.LcCameraCountL(), KErrNotReady ) |
|
182 |
|
183 iCameraHandler.SetSession( iSession ); |
|
184 CMceCameraSource* camera = |
|
185 MusEngMceUtils::GetCameraL( *( iSession ) ); |
|
186 iCameraHandler.iCameraUsage = MusSettingsKeys::EUseCameraSwapping; |
|
187 camera->iCameraCount = 2; |
|
188 camera->iCameraIndex = TMusEngCameraHandler::EBackCamera; |
|
189 |
|
190 // Two cameras |
|
191 EUNIT_ASSERT_EQUALS( 2, iCameraHandler.LcCameraCountL() ) |
|
192 |
|
193 // Two cameras, swapping cameras not allowed, use only main camera |
|
194 iCameraHandler.iCameraUsage = MusSettingsKeys::EUseOnlyMainCamera; |
|
195 camera->iCameraCount = 2; |
|
196 EUNIT_ASSERT_EQUALS( 1, iCameraHandler.LcCameraCountL() ) |
|
197 |
|
198 // Two cameras, swapping cameras not allowed, use only main camera |
|
199 iCameraHandler.iCameraUsage = MusSettingsKeys::EUseOnlySecondaryCamera; |
|
200 camera->iCameraCount = 2; |
|
201 EUNIT_ASSERT_EQUALS( 1, iCameraHandler.LcCameraCountL() ) |
|
202 |
|
203 // Only one camera available |
|
204 iCameraHandler.iCameraUsage = MusSettingsKeys::EUseCameraSwapping; |
|
205 camera->iCameraCount = 1; |
|
206 EUNIT_ASSERT_EQUALS( 1, iCameraHandler.LcCameraCountL() ) |
|
207 } |
|
208 |
|
209 // ----------------------------------------------------------------------------- |
|
210 // |
|
211 // ----------------------------------------------------------------------------- |
|
212 // |
|
213 void UT_TMusEngCameraHandler::UT_ToggleLcCameraL() |
|
214 { |
|
215 EUNIT_ASSERT_EQUALS( TInt( TMusEngCameraHandler::ECameraNotAvailable ), |
|
216 iCameraHandler.CurrentLcCameraIndex() ) |
|
217 |
|
218 iCameraHandler.SetSession( iSession ); |
|
219 iCameraHandler.iCameraUsage = MusSettingsKeys::EUseCameraSwapping; |
|
220 iCameraHandler.iCurrentCamera = TMusEngCameraHandler::EBackCamera; |
|
221 |
|
222 // Switch from back to front |
|
223 iCameraHandler.ToggleLcCameraL(); |
|
224 EUNIT_ASSERT_EQUALS( TInt( TMusEngCameraHandler::EFrontCamera ), |
|
225 iCameraHandler.CurrentLcCameraIndex() ) |
|
226 |
|
227 // Switch from front to back |
|
228 iCameraHandler.ToggleLcCameraL(); |
|
229 EUNIT_ASSERT_EQUALS( TInt( TMusEngCameraHandler::EBackCamera ), |
|
230 iCameraHandler.CurrentLcCameraIndex() ) |
|
231 } |
|
232 |
|
233 // ----------------------------------------------------------------------------- |
|
234 // |
|
235 // ----------------------------------------------------------------------------- |
|
236 // |
|
237 void UT_TMusEngCameraHandler::UT_MinLcZoomL() |
|
238 { |
|
239 // MCE Session has not been set |
|
240 EUNIT_ASSERT_SPECIFIC_LEAVE( iCameraHandler.MinLcZoomL(), KErrNotReady ) |
|
241 |
|
242 // MCE Session has been set |
|
243 iCameraHandler.SetSession( iSession ); |
|
244 EUNIT_ASSERT_EQUALS( |
|
245 iCameraHandler.iCameraInfo.iMinZoom, |
|
246 iCameraHandler.MinLcZoomL() ) |
|
247 } |
|
248 |
|
249 // ----------------------------------------------------------------------------- |
|
250 // |
|
251 // ----------------------------------------------------------------------------- |
|
252 // |
|
253 void UT_TMusEngCameraHandler::UT_MaxLcZoomL() |
|
254 { |
|
255 // MCE Session has not been set |
|
256 EUNIT_ASSERT_SPECIFIC_LEAVE( iCameraHandler.MaxLcZoomL(), KErrNotReady ) |
|
257 |
|
258 // MCE Session has been set |
|
259 iCameraHandler.SetSession( iSession ); |
|
260 EUNIT_ASSERT_EQUALS( |
|
261 iCameraHandler.iCameraInfo.iMaxZoom + |
|
262 iCameraHandler.iCameraInfo.iMaxDigitalZoom, |
|
263 iCameraHandler.MaxLcZoomL() ) |
|
264 } |
|
265 |
|
266 // ----------------------------------------------------------------------------- |
|
267 // |
|
268 // ----------------------------------------------------------------------------- |
|
269 // |
|
270 void UT_TMusEngCameraHandler::UT_LcZoomValueL() |
|
271 { |
|
272 // MCE Session has not been set |
|
273 EUNIT_ASSERT_SPECIFIC_LEAVE( iCameraHandler.LcZoomValueL(), KErrNotReady ) |
|
274 |
|
275 // Check that originally current and default zoom are the same |
|
276 iCameraHandler.SetSession( iSession ); |
|
277 CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *( iSession ) ); |
|
278 |
|
279 // Zoom to maximum optical value |
|
280 while ( camera->iZoomFactor < iCameraHandler.iCameraInfo.iMaxZoom ) |
|
281 { |
|
282 iCameraHandler.LcZoomInL(); |
|
283 } |
|
284 EUNIT_ASSERT_EQUALS( |
|
285 iCameraHandler.iCameraInfo.iMaxZoom, |
|
286 iCameraHandler.LcZoomValueL() ) |
|
287 |
|
288 // Zoom using digital zoom |
|
289 iCameraHandler.LcZoomInL(); |
|
290 EUNIT_ASSERT_EQUALS( |
|
291 iCameraHandler.iCameraInfo.iMaxZoom + camera->iDigitalZoomFactor, |
|
292 iCameraHandler.LcZoomValueL() ) |
|
293 } |
|
294 |
|
295 // ----------------------------------------------------------------------------- |
|
296 // |
|
297 // ----------------------------------------------------------------------------- |
|
298 // |
|
299 void UT_TMusEngCameraHandler::UT_SetLcZoomValueL() |
|
300 { |
|
301 // MCE Session has not been set |
|
302 EUNIT_ASSERT_SPECIFIC_LEAVE( |
|
303 iCameraHandler.SetLcZoomValueL( 1 ), |
|
304 KErrNotReady ) |
|
305 |
|
306 // Value above the maximum zoom |
|
307 iCameraHandler.SetSession( iSession ); |
|
308 EUNIT_ASSERT_SPECIFIC_LEAVE( |
|
309 iCameraHandler.SetLcZoomValueL( iCameraHandler.MaxLcZoomL() + 1 ), |
|
310 KErrArgument ) |
|
311 |
|
312 // Value below the minimum zoom |
|
313 EUNIT_ASSERT_SPECIFIC_LEAVE( |
|
314 iCameraHandler.SetLcZoomValueL( iCameraHandler.MinLcZoomL() - 1 ), |
|
315 KErrArgument ) |
|
316 |
|
317 // OK: set zoom factor |
|
318 CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *iSession ); |
|
319 TInt zoomValue = iCameraHandler.iCameraInfo.iMaxZoom - 1; |
|
320 iCameraHandler.SetLcZoomValueL( zoomValue ); |
|
321 EUNIT_ASSERT_EQUALS( zoomValue, camera->ZoomFactorL() ) |
|
322 |
|
323 // OK: set digital zoom factor |
|
324 zoomValue = iCameraHandler.iCameraInfo.iMaxZoom + 1; |
|
325 iCameraHandler.SetLcZoomValueL( zoomValue ); |
|
326 EUNIT_ASSERT_EQUALS( 1, camera->DigitalZoomFactorL() ) |
|
327 } |
|
328 |
|
329 // ----------------------------------------------------------------------------- |
|
330 // |
|
331 // ----------------------------------------------------------------------------- |
|
332 // |
|
333 void UT_TMusEngCameraHandler::UT_LcZoomInL() |
|
334 { |
|
335 // Check that zooming is not possible before invite |
|
336 TRAPD( error, iCameraHandler.LcZoomInL() ); |
|
337 MUS_TEST_FORWARD_ALLOC_FAILURE( error ); |
|
338 EUNIT_ASSERT( error == KErrNotReady ); |
|
339 |
|
340 iCameraHandler.SetSession( iSession ); |
|
341 |
|
342 CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *( iSession ) ); |
|
343 |
|
344 TInt oldZoomFactor = camera->iZoomFactor; |
|
345 |
|
346 // Check that zoom factor can be increased |
|
347 USER_SLEEP; //insure that small step is used |
|
348 iCameraHandler.LcZoomInL(); |
|
349 EUNIT_ASSERT( camera->iZoomFactor == oldZoomFactor + |
|
350 iCameraHandler.iSmallZoomStep ); |
|
351 |
|
352 //Check the "burst" mode (immediate second ZoomIn), big step should be used |
|
353 TInt nZoom = camera->iZoomFactor + camera->iDigitalZoomFactor; |
|
354 iCameraHandler.LcZoomInL(); |
|
355 TInt nStep = camera->iZoomFactor + camera->iDigitalZoomFactor - nZoom; |
|
356 EUNIT_ASSERT( nStep == iCameraHandler.iBigZoomStep ); |
|
357 |
|
358 // Zoom to maximum optical value |
|
359 while ( camera->iZoomFactor < iCameraHandler.iCameraInfo.iMaxZoom ) |
|
360 { |
|
361 iCameraHandler.LcZoomInL(); |
|
362 } |
|
363 |
|
364 TInt maxOpticalZoomFactor = camera->ZoomFactorL(); |
|
365 |
|
366 // Check that digital zoom is used instead of optical |
|
367 iCameraHandler.LcZoomInL(); |
|
368 EUNIT_ASSERT( camera->iZoomFactor == maxOpticalZoomFactor ); |
|
369 EUNIT_ASSERT( camera->iDigitalZoomFactor > 0 ); |
|
370 |
|
371 // Zoom to maximum digital value |
|
372 while ( camera->iDigitalZoomFactor < |
|
373 iCameraHandler.iCameraInfo.iMaxDigitalZoom ) |
|
374 { |
|
375 iCameraHandler.LcZoomInL(); |
|
376 } |
|
377 |
|
378 TInt maxDigitalZoomFactor = camera->DigitalZoomFactorL(); |
|
379 |
|
380 // Check that further zooming is impossible |
|
381 iCameraHandler.LcZoomInL(); |
|
382 EUNIT_ASSERT( camera->iZoomFactor == maxOpticalZoomFactor ); |
|
383 EUNIT_ASSERT( camera->iDigitalZoomFactor == maxDigitalZoomFactor ); |
|
384 } |
|
385 |
|
386 // ----------------------------------------------------------------------------- |
|
387 // |
|
388 // ----------------------------------------------------------------------------- |
|
389 // |
|
390 void UT_TMusEngCameraHandler::UT_LcZoomOutL() |
|
391 { |
|
392 // Check that zooming is not possible before invite |
|
393 TRAPD( error, iCameraHandler.LcZoomOutL() ); |
|
394 MUS_TEST_FORWARD_ALLOC_FAILURE( error ); |
|
395 EUNIT_ASSERT( error == KErrNotReady ); |
|
396 |
|
397 iCameraHandler.SetSession( iSession ); |
|
398 |
|
399 CMceCameraSource* camera = |
|
400 MusEngMceUtils::GetCameraL( *(iSession) ); |
|
401 |
|
402 // Simulate maximum zoom |
|
403 camera->iZoomFactor = iCameraHandler.iCameraInfo.iMaxZoom; |
|
404 camera->iDigitalZoomFactor = iCameraHandler.iCameraInfo.iMaxDigitalZoom; |
|
405 |
|
406 // Check that digital zoom factor can be decreased |
|
407 USER_SLEEP; //insure that small step is used |
|
408 iCameraHandler.LcZoomOutL(); |
|
409 EUNIT_ASSERT( camera->iZoomFactor == iCameraHandler.iCameraInfo.iMaxZoom ); |
|
410 EUNIT_ASSERT( camera->iDigitalZoomFactor == |
|
411 iCameraHandler.iCameraInfo.iMaxDigitalZoom - |
|
412 iCameraHandler.iSmallZoomStep ); |
|
413 |
|
414 //Check the "burst" mode (immediate second ZoomOut), big step should be used |
|
415 TInt nZoom = camera->iZoomFactor + camera->iDigitalZoomFactor; |
|
416 iCameraHandler.LcZoomOutL(); |
|
417 TInt nStep; |
|
418 nStep = nZoom - (camera->iZoomFactor + camera->iDigitalZoomFactor ); |
|
419 EUNIT_ASSERT( nStep == iCameraHandler.iBigZoomStep ); |
|
420 |
|
421 // Simulate maximum zoom again |
|
422 camera->iZoomFactor = iCameraHandler.iCameraInfo.iMaxZoom; |
|
423 camera->iDigitalZoomFactor = iCameraHandler.iCameraInfo.iMaxDigitalZoom; |
|
424 |
|
425 // Zoom to minimum digital zoom |
|
426 while ( camera->iDigitalZoomFactor > 0 ) |
|
427 { |
|
428 iCameraHandler.LcZoomOutL(); |
|
429 } |
|
430 |
|
431 EUNIT_ASSERT( camera->iZoomFactor == iCameraHandler.iCameraInfo.iMaxZoom ); |
|
432 EUNIT_ASSERT( camera->iDigitalZoomFactor == 0 ); |
|
433 |
|
434 // Check that optical zoom is decreased instead of digital |
|
435 USER_SLEEP; //insure that step is the small one |
|
436 iCameraHandler.LcZoomOutL(); |
|
437 EUNIT_ASSERT( camera->iZoomFactor == |
|
438 iCameraHandler.iCameraInfo.iMaxZoom - |
|
439 iCameraHandler.iSmallZoomStep ); |
|
440 EUNIT_ASSERT( camera->iDigitalZoomFactor == 0 ); |
|
441 |
|
442 // Zoom to minimum optical zoom |
|
443 while ( camera->iZoomFactor > iCameraHandler.iCameraInfo.iMinZoom ) |
|
444 { |
|
445 iCameraHandler.LcZoomOutL(); |
|
446 } |
|
447 |
|
448 // Check that further zooming is impossible |
|
449 iCameraHandler.LcZoomOutL(); |
|
450 EUNIT_ASSERT( camera->iZoomFactor == iCameraHandler.iCameraInfo.iMinZoom ); |
|
451 EUNIT_ASSERT( camera->iDigitalZoomFactor == 0 ); |
|
452 } |
|
453 |
|
454 // ----------------------------------------------------------------------------- |
|
455 // |
|
456 // ----------------------------------------------------------------------------- |
|
457 // |
|
458 void UT_TMusEngCameraHandler::UT_SetLcBrightnessL() |
|
459 { |
|
460 // Check that setting brightness is not possible before invite |
|
461 EUNIT_ASSERT_SPECIFIC_LEAVE( |
|
462 iCameraHandler.SetLcBrightnessL( KTestSomeBrightness ), |
|
463 KErrNotReady ) |
|
464 |
|
465 iCameraHandler.SetSession( iSession ); |
|
466 CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *( iSession ) ); |
|
467 |
|
468 camera->iCameraInfo.iOptionsSupported = |
|
469 camera->iCameraInfo.iOptionsSupported|TCameraInfo::EBrightnessSupported; |
|
470 |
|
471 // Check that originally current and default brightness are the same |
|
472 EUNIT_ASSERT_EQUALS( iCameraHandler.iDefaultBrightness, |
|
473 iCameraHandler.LcBrightnessL() ) |
|
474 |
|
475 // Test setting brightness |
|
476 iCameraHandler.SetLcBrightnessL( KTestSomeBrightness ); |
|
477 EUNIT_ASSERT_EQUALS( KTestSomeBrightness, iCameraHandler.LcBrightnessL() ) |
|
478 } |
|
479 |
|
480 // ----------------------------------------------------------------------------- |
|
481 // |
|
482 // ----------------------------------------------------------------------------- |
|
483 // |
|
484 void UT_TMusEngCameraHandler::UT_LcBrightnessL() |
|
485 { |
|
486 // Check that checking current brightness is not possible before invite |
|
487 EUNIT_ASSERT_SPECIFIC_LEAVE( iCameraHandler.LcBrightnessL(), |
|
488 KErrNotReady ) |
|
489 |
|
490 // All the other stuff checked in tests of SetBrightnessL |
|
491 } |
|
492 |
|
493 // ----------------------------------------------------------------------------- |
|
494 // |
|
495 // ----------------------------------------------------------------------------- |
|
496 // |
|
497 void UT_TMusEngCameraHandler::UT_MaxLcBrightnessL() |
|
498 { |
|
499 // MaxBrightness should return a constant |
|
500 EUNIT_ASSERT_EQUALS( KTestMaxBrightness, iCameraHandler.MaxLcBrightnessL() ) |
|
501 } |
|
502 |
|
503 // ----------------------------------------------------------------------------- |
|
504 // |
|
505 // ----------------------------------------------------------------------------- |
|
506 // |
|
507 void UT_TMusEngCameraHandler::UT_MinLcBrightnessL() |
|
508 { |
|
509 // MinBrightness should return a constant |
|
510 |
|
511 EUNIT_ASSERT_EQUALS( KTestMinBrightness, iCameraHandler.MinLcBrightnessL() ) |
|
512 } |
|
513 |
|
514 // ----------------------------------------------------------------------------- |
|
515 // |
|
516 // ----------------------------------------------------------------------------- |
|
517 // |
|
518 void UT_TMusEngCameraHandler::UT_IncreaseLcBrightnessL() |
|
519 { |
|
520 // Check that increasing brightness is not possible before invite |
|
521 EUNIT_ASSERT_SPECIFIC_LEAVE( iCameraHandler.IncreaseLcBrightnessL(), |
|
522 KErrNotReady ) |
|
523 |
|
524 iCameraHandler.SetSession( iSession ); |
|
525 CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *(iSession) ); |
|
526 |
|
527 camera->iCameraInfo.iOptionsSupported = |
|
528 camera->iCameraInfo.iOptionsSupported|TCameraInfo::EBrightnessSupported; |
|
529 |
|
530 // Check that originally current and default brightness are the same |
|
531 EUNIT_ASSERT_EQUALS( iCameraHandler.iDefaultBrightness, |
|
532 iCameraHandler.LcBrightnessL() ) |
|
533 |
|
534 // Check that brightness can be increased... |
|
535 iCameraHandler.IncreaseLcBrightnessL(); |
|
536 EUNIT_ASSERT_EQUALS( iCameraHandler.iDefaultBrightness + KTestBrightnessStepSize, |
|
537 iCameraHandler.LcBrightnessL() ) |
|
538 |
|
539 // ... but only to maximum |
|
540 iCameraHandler.SetLcBrightnessL( KTestMaxBrightness ); |
|
541 iCameraHandler.IncreaseLcBrightnessL(); |
|
542 |
|
543 EUNIT_ASSERT_EQUALS( KTestMaxBrightness, |
|
544 iCameraHandler.LcBrightnessL() ) |
|
545 } |
|
546 |
|
547 // ----------------------------------------------------------------------------- |
|
548 // |
|
549 // ----------------------------------------------------------------------------- |
|
550 // |
|
551 void UT_TMusEngCameraHandler::UT_DecreaseLcBrightnessL() |
|
552 { |
|
553 // Check that decreasing brightness is not possible before invite |
|
554 EUNIT_ASSERT_SPECIFIC_LEAVE( iCameraHandler.DecreaseLcBrightnessL(), |
|
555 KErrNotReady ) |
|
556 |
|
557 iCameraHandler.SetSession( iSession ); |
|
558 CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *(iSession) ); |
|
559 |
|
560 camera->iCameraInfo.iOptionsSupported = |
|
561 camera->iCameraInfo.iOptionsSupported|TCameraInfo::EBrightnessSupported; |
|
562 |
|
563 // Check that originally current and default brightness are the same |
|
564 EUNIT_ASSERT_EQUALS( iCameraHandler.iDefaultBrightness, |
|
565 iCameraHandler.LcBrightnessL() ) |
|
566 |
|
567 // Check that brightness can be decreased... |
|
568 iCameraHandler.DecreaseLcBrightnessL(); |
|
569 |
|
570 EUNIT_ASSERT_EQUALS( |
|
571 iCameraHandler.iDefaultBrightness - KTestBrightnessStepSize, |
|
572 iCameraHandler.LcBrightnessL() ) |
|
573 |
|
574 // ... but only to minimum |
|
575 iCameraHandler.SetLcBrightnessL( KTestMinBrightness ); |
|
576 iCameraHandler.DecreaseLcBrightnessL(); |
|
577 EUNIT_ASSERT_EQUALS( KTestMinBrightness, |
|
578 iCameraHandler.LcBrightnessL() ) |
|
579 } |
|
580 |
|
581 // ----------------------------------------------------------------------------- |
|
582 // |
|
583 // ----------------------------------------------------------------------------- |
|
584 // |
|
585 void UT_TMusEngCameraHandler::UT_PlayL() |
|
586 { |
|
587 // Check that resuming is not possible before invite |
|
588 EUNIT_ASSERT_SPECIFIC_LEAVE( iCameraHandler.PlayL(), KErrNotReady ) |
|
589 |
|
590 iCameraHandler.SetSession( iSession ); |
|
591 |
|
592 iCameraHandler.PauseL(); |
|
593 |
|
594 CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *(iSession) ); |
|
595 iCameraHandler.PlayL(); |
|
596 EUNIT_ASSERT( camera->IsEnabled() ) |
|
597 |
|
598 // Try to enable camera again, request should be ignored |
|
599 iCameraHandler.PlayL(); |
|
600 EUNIT_ASSERT( camera->IsEnabled() ) |
|
601 } |
|
602 |
|
603 // ----------------------------------------------------------------------------- |
|
604 // |
|
605 // ----------------------------------------------------------------------------- |
|
606 // |
|
607 void UT_TMusEngCameraHandler::UT_PauseL() |
|
608 { |
|
609 // Check that pausing is not possible before invite |
|
610 EUNIT_ASSERT_SPECIFIC_LEAVE( iCameraHandler.PauseL(), KErrNotReady ) |
|
611 |
|
612 iCameraHandler.SetSession( iSession ); |
|
613 |
|
614 iCameraHandler.PlayL(); |
|
615 |
|
616 CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *(iSession) ); |
|
617 |
|
618 iCameraHandler.PauseL(); |
|
619 |
|
620 EUNIT_ASSERT( !camera->IsEnabled() ) |
|
621 |
|
622 // Try to disable camera again, request should be ignored |
|
623 iCameraHandler.PauseL(); |
|
624 EUNIT_ASSERT( !camera->IsEnabled() ) |
|
625 } |
|
626 |
|
627 // ----------------------------------------------------------------------------- |
|
628 // |
|
629 // ----------------------------------------------------------------------------- |
|
630 // |
|
631 void UT_TMusEngCameraHandler::UT_IsPlayingL() |
|
632 { |
|
633 // Try without a session |
|
634 EUNIT_ASSERT_SPECIFIC_LEAVE( iCameraHandler.IsPlayingL(), KErrNotReady ) |
|
635 |
|
636 // Normal cases |
|
637 iCameraHandler.SetSession( iSession ); |
|
638 |
|
639 iCameraHandler.PlayL(); |
|
640 EUNIT_ASSERT( iCameraHandler.IsPlayingL() ) |
|
641 |
|
642 iCameraHandler.PauseL(); |
|
643 EUNIT_ASSERT( !iCameraHandler.IsPlayingL() ) |
|
644 } |
|
645 |
|
646 // ----------------------------------------------------------------------------- |
|
647 // |
|
648 // ----------------------------------------------------------------------------- |
|
649 // |
|
650 void UT_TMusEngCameraHandler::UT_InitializeZoomStepSizeL() |
|
651 { |
|
652 //Check that zooming steps have defualt values before session establishment |
|
653 iCameraHandler.InitializeZoomStepSize(); |
|
654 EUNIT_ASSERT( iCameraHandler.iSmallZoomStep == KZoomStepMinSize ); |
|
655 EUNIT_ASSERT( iCameraHandler.iBigZoomStep == KZoomStepMinSize ); |
|
656 |
|
657 iCameraHandler.SetSession( iSession ); |
|
658 CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *(iSession) ); |
|
659 |
|
660 //Check that zooming step sizes have default value KZoomStepMinSize |
|
661 //in case of zooming values range is smaller than KZoomBigStepCount |
|
662 iCameraHandler.iCameraInfo.iMinZoom = 0; |
|
663 iCameraHandler.iCameraInfo.iMaxZoom = 0; |
|
664 iCameraHandler.iCameraInfo.iMaxDigitalZoom = KZoomBigStepCount / 2; |
|
665 iCameraHandler.InitializeZoomStepSize(); |
|
666 EUNIT_ASSERT( iCameraHandler.iSmallZoomStep == KZoomStepMinSize ); |
|
667 EUNIT_ASSERT( iCameraHandler.iBigZoomStep == KZoomStepMinSize ); |
|
668 |
|
669 //Check that zooming step sizes have default value KZoomStepMinSize |
|
670 //in case of zooming values range is bigger than KZoomBigStepCount, |
|
671 //but smaller than 2*KZoomBigStepCount (KZoomSmallStepCount) |
|
672 iCameraHandler.iCameraInfo.iMaxDigitalZoom = 2*KZoomBigStepCount - 1; |
|
673 iCameraHandler.InitializeZoomStepSize(); |
|
674 EUNIT_ASSERT( iCameraHandler.iSmallZoomStep == KZoomStepMinSize ); |
|
675 EUNIT_ASSERT( iCameraHandler.iBigZoomStep == KZoomStepMinSize ); |
|
676 |
|
677 //Check zooming steps sizes in case of zooming values range is |
|
678 //bigger than 2*KZoomBigStepCount and smaller than 2*KZoomSmallStepCount |
|
679 iCameraHandler.iCameraInfo.iMinZoom = - KZoomBigStepCount; |
|
680 iCameraHandler.iCameraInfo.iMaxZoom = KZoomBigStepCount; |
|
681 iCameraHandler.iCameraInfo.iMaxDigitalZoom = KZoomBigStepCount; |
|
682 //zooming range is (-KZoomBigStepCount, 2*KZoomBigStepCount) |
|
683 iCameraHandler.InitializeZoomStepSize(); |
|
684 EUNIT_ASSERT( iCameraHandler.iSmallZoomStep == KZoomStepMinSize ); |
|
685 EUNIT_ASSERT( iCameraHandler.iBigZoomStep == 3 ); |
|
686 |
|
687 //Check zooming steps sizes in case of zooming values range is |
|
688 //bigger than 2*KZoomSmallStepCount |
|
689 iCameraHandler.iCameraInfo.iMaxZoom = KZoomSmallStepCount; |
|
690 iCameraHandler.iCameraInfo.iMaxDigitalZoom = KZoomSmallStepCount; |
|
691 iCameraHandler.iCameraInfo.iMinZoom = - KZoomSmallStepCount; |
|
692 //zooming range is (-KZoomSmallStepCount, 2*KZoomSmallStepCount) |
|
693 iCameraHandler.InitializeZoomStepSize(); |
|
694 EUNIT_ASSERT( iCameraHandler.iSmallZoomStep == 3 ); |
|
695 EUNIT_ASSERT( iCameraHandler.iBigZoomStep == 6 ); |
|
696 } |
|
697 |
|
698 // ----------------------------------------------------------------------------- |
|
699 // |
|
700 // ----------------------------------------------------------------------------- |
|
701 // |
|
702 void UT_TMusEngCameraHandler::UT_ChangeActiveCameraL() |
|
703 { |
|
704 iCameraHandler.SetSession( iSession ); |
|
705 |
|
706 CMceCameraSource* camera = |
|
707 MusEngMceUtils::GetCameraL( *(iSession) ); |
|
708 |
|
709 //Camera is not enabled |
|
710 camera->iIsEnabled = ETrue; |
|
711 camera->iCameraCount = 2; |
|
712 camera->iCameraIndex = 1; |
|
713 iCameraHandler.ChangeActiveCameraL( TMusEngCameraHandler::EFrontCamera ); |
|
714 EUNIT_ASSERT( camera->iCameraIndex == 1 ); |
|
715 EUNIT_ASSERT( camera->iIsEnabled == ETrue ); |
|
716 |
|
717 //Camera is not enabled |
|
718 camera->iIsEnabled = EFalse; |
|
719 camera->iCameraCount = 2; |
|
720 camera->iCameraIndex = 1; |
|
721 iCameraHandler.ChangeActiveCameraL( TMusEngCameraHandler::EFrontCamera ); |
|
722 EUNIT_ASSERT( camera->iCameraIndex == 1 ); |
|
723 EUNIT_ASSERT( camera->iIsEnabled == EFalse ); |
|
724 |
|
725 //Check that iCameraInfo get updated after camera change |
|
726 EUNIT_PRINT(_L("Check that iCameraInfo get updated after camera change")); |
|
727 |
|
728 //Check that iCameraInfo get updated after camera change |
|
729 EUNIT_PRINT(_L("Check that iCameraInfo get updated after camera change")); |
|
730 camera->iIsEnabled = ETrue; |
|
731 camera->iCameraCount = 2; |
|
732 camera->iCameraIndex = 0; |
|
733 iCameraHandler.ChangeActiveCameraL( TMusEngCameraHandler::EBackCamera ); |
|
734 EUNIT_ASSERT( camera->iCameraIndex == 0 ); |
|
735 TCameraInfo infoBack = iCameraHandler.iCameraInfo; |
|
736 iCameraHandler.ChangeActiveCameraL( TMusEngCameraHandler::EFrontCamera ); |
|
737 EUNIT_ASSERT( camera->iCameraIndex == 1 ); |
|
738 TCameraInfo infoFront = iCameraHandler.iCameraInfo; |
|
739 |
|
740 EUNIT_ASSERT( infoBack.iMaxZoom != infoFront.iMaxZoom ); |
|
741 EUNIT_ASSERT( infoBack.iMaxDigitalZoom != infoFront.iMaxDigitalZoom ); |
|
742 camera->iIsEnabled = ETrue; |
|
743 } |
|
744 |
|
745 // ----------------------------------------------------------------------------- |
|
746 // |
|
747 // ----------------------------------------------------------------------------- |
|
748 // |
|
749 void UT_TMusEngCameraHandler::UT_ChangeCameraL() |
|
750 { |
|
751 TRAPD( error, iCameraHandler.ChangeCameraL( TMusEngCameraHandler::EFrontCamera ) ); |
|
752 MUS_TEST_FORWARD_ALLOC_FAILURE( error ); |
|
753 EUNIT_ASSERT( error == KErrNotReady ); |
|
754 |
|
755 iCameraHandler.SetSession( iSession ); |
|
756 |
|
757 CMceCameraSource* camera = |
|
758 MusEngMceUtils::GetCameraL( *(iSession) ); |
|
759 //Only one camera is supported |
|
760 camera->iCameraCount = 0; |
|
761 camera->iCameraIndex = 0; |
|
762 |
|
763 iCameraHandler.ChangeCameraL( TMusEngCameraHandler::EFrontCamera ); |
|
764 //EUNIT_ASSERT( camera->iCameraIndex == 0 ); |
|
765 |
|
766 // Front camera is supported. |
|
767 camera->iCameraCount = 2; |
|
768 camera->iCameraIndex = 1; |
|
769 iCameraHandler.ChangeCameraL( TMusEngCameraHandler::EFrontCamera ); |
|
770 EUNIT_ASSERT( camera->iCameraIndex == 1 ); |
|
771 |
|
772 //No change |
|
773 camera->iCameraCount = 2; |
|
774 camera->iCameraIndex = 0; |
|
775 camera->iIsEnabled = EFalse; |
|
776 iCameraHandler.ChangeCameraL( TMusEngCameraHandler::EFrontCamera ); |
|
777 EUNIT_ASSERT( camera->iIsEnabled == EFalse ); |
|
778 |
|
779 // Back camera is supported. |
|
780 camera->iCameraCount = 2; |
|
781 camera->iCameraIndex = 1; |
|
782 iCameraHandler.ChangeCameraL( TMusEngCameraHandler::EBackCamera ); |
|
783 EUNIT_ASSERT( camera->iCameraIndex == 0 ); |
|
784 |
|
785 //No change |
|
786 camera->iCameraCount = 2; |
|
787 camera->iCameraIndex = 0; |
|
788 camera->iIsEnabled = EFalse; |
|
789 iCameraHandler.ChangeCameraL( TMusEngCameraHandler::EBackCamera ); |
|
790 EUNIT_ASSERT( camera->iIsEnabled == EFalse ); |
|
791 |
|
792 // Next camera. |
|
793 camera->iCameraCount = 2; |
|
794 camera->iCameraIndex = 0; |
|
795 iCameraHandler.ChangeCameraL( TMusEngCameraHandler::ECameraNotAvailable ); |
|
796 EUNIT_ASSERT( camera->iCameraIndex == 1 ); |
|
797 |
|
798 camera->iCameraCount = 2; |
|
799 camera->iCameraIndex = 1; |
|
800 iCameraHandler.ChangeCameraL( TMusEngCameraHandler::ECameraNotAvailable ); |
|
801 EUNIT_ASSERT( camera->iCameraIndex == 0 ); |
|
802 } |
|
803 |
|
804 |
|
805 // TEST TABLE |
|
806 |
|
807 EUNIT_BEGIN_TEST_TABLE( |
|
808 UT_TMusEngCameraHandler, |
|
809 "UT_TMusEngCameraHandler", |
|
810 "UNIT" ) |
|
811 |
|
812 EUNIT_TEST( |
|
813 "LcCameraCountL - test ", |
|
814 "TMusEngCameraHandler", |
|
815 "LcCameraCountL", |
|
816 "FUNCTIONALITY", |
|
817 SetupL, UT_LcCameraCountL, Teardown) |
|
818 |
|
819 EUNIT_TEST( |
|
820 "ToggleLcCameraL - test ", |
|
821 "TMusEngCameraHandler", |
|
822 "ToggleLcCameraL", |
|
823 "FUNCTIONALITY", |
|
824 SetupL, UT_ToggleLcCameraL, Teardown) |
|
825 |
|
826 EUNIT_TEST( |
|
827 "MinLcZoomL - test ", |
|
828 "TMusEngCameraHandler", |
|
829 "MinLcZoomL", |
|
830 "FUNCTIONALITY", |
|
831 SetupL, UT_MinLcZoomL, Teardown) |
|
832 |
|
833 EUNIT_TEST( |
|
834 "MaxLcZoomL - test ", |
|
835 "TMusEngCameraHandler", |
|
836 "MaxLcZoomL", |
|
837 "FUNCTIONALITY", |
|
838 SetupL, UT_MaxLcZoomL, Teardown) |
|
839 |
|
840 EUNIT_TEST( |
|
841 "LcZoomValueL - test ", |
|
842 "TMusEngCameraHandler", |
|
843 "LcZoomValueL", |
|
844 "FUNCTIONALITY", |
|
845 SetupL, UT_LcZoomValueL, Teardown) |
|
846 |
|
847 EUNIT_TEST( |
|
848 "SetLcZoomValueL - test ", |
|
849 "TMusEngCameraHandler", |
|
850 "SetLcZoomValueL", |
|
851 "FUNCTIONALITY", |
|
852 SetupL, UT_SetLcZoomValueL, Teardown) |
|
853 |
|
854 EUNIT_TEST( |
|
855 "LcZoomInL - test ", |
|
856 "TMusEngCameraHandler", |
|
857 "LcZoomInL", |
|
858 "FUNCTIONALITY", |
|
859 SetupL, UT_LcZoomInL, Teardown) |
|
860 |
|
861 EUNIT_TEST( |
|
862 "LcZoomOutL - test ", |
|
863 "TMusEngCameraHandler", |
|
864 "LcZoomOutL", |
|
865 "FUNCTIONALITY", |
|
866 SetupL, UT_LcZoomOutL, Teardown) |
|
867 |
|
868 EUNIT_TEST( |
|
869 "SetLcBrightnessL - test ", |
|
870 "TMusEngCameraHandler", |
|
871 "SetLcBrightnessL", |
|
872 "FUNCTIONALITY", |
|
873 SetupL, UT_SetLcBrightnessL, Teardown) |
|
874 |
|
875 EUNIT_TEST( |
|
876 "LcBrightnessL - test ", |
|
877 "TMusEngCameraHandler", |
|
878 "LcBrightnessL", |
|
879 "FUNCTIONALITY", |
|
880 SetupL, UT_LcBrightnessL, Teardown) |
|
881 |
|
882 EUNIT_TEST( |
|
883 "MaxLcBrightnessL - test ", |
|
884 "TMusEngCameraHandler", |
|
885 "MaxLcBrightnessL", |
|
886 "FUNCTIONALITY", |
|
887 SetupL, UT_MaxLcBrightnessL, Teardown) |
|
888 |
|
889 EUNIT_TEST( |
|
890 "MinLcBrightnessL - test ", |
|
891 "TMusEngCameraHandler", |
|
892 "MinLcBrightnessL", |
|
893 "FUNCTIONALITY", |
|
894 SetupL, UT_MinLcBrightnessL, Teardown) |
|
895 |
|
896 EUNIT_TEST( |
|
897 "IncreaseLcBrightnessL - test ", |
|
898 "TMusEngCameraHandler", |
|
899 "IncreaseLcBrightnessL", |
|
900 "FUNCTIONALITY", |
|
901 SetupL, UT_IncreaseLcBrightnessL, Teardown) |
|
902 |
|
903 EUNIT_TEST( |
|
904 "DecreaseLcBrightnessL - test ", |
|
905 "TMusEngCameraHandler", |
|
906 "DecreaseLcBrightnessL", |
|
907 "FUNCTIONALITY", |
|
908 SetupL, UT_DecreaseLcBrightnessL, Teardown) |
|
909 |
|
910 EUNIT_TEST( |
|
911 "PlayL - test ", |
|
912 "TMusEngCameraHandler", |
|
913 "PlayL", |
|
914 "FUNCTIONALITY", |
|
915 SetupL, UT_PlayL, Teardown) |
|
916 |
|
917 EUNIT_TEST( |
|
918 "PauseL - test ", |
|
919 "TMusEngCameraHandler", |
|
920 "PauseL", |
|
921 "FUNCTIONALITY", |
|
922 SetupL, UT_PauseL, Teardown) |
|
923 |
|
924 EUNIT_TEST( |
|
925 "IsPlayingL - test ", |
|
926 "TMusEngCameraHandler", |
|
927 "IsPlayingL", |
|
928 "FUNCTIONALITY", |
|
929 SetupL, UT_IsPlayingL, Teardown) |
|
930 |
|
931 EUNIT_TEST( |
|
932 "InitializeZoomStepSize - test ", |
|
933 "TMusEngCameraHandler", |
|
934 "InitializeZoomStepSize", |
|
935 "FUNCTIONALITY", |
|
936 SetupL, UT_InitializeZoomStepSizeL, Teardown) |
|
937 |
|
938 EUNIT_TEST( |
|
939 "ChangeCameraL - test ", |
|
940 "TMusEngCameraHandler", |
|
941 "ChangeCameraL", |
|
942 "FUNCTIONALITY", |
|
943 SetupL, UT_ChangeCameraL, Teardown) |
|
944 |
|
945 EUNIT_TEST( |
|
946 "UT_ChangeActiveCameraL - test ", |
|
947 "TMusEngCameraHandler", |
|
948 "DisableAndEnableBeforeChangingCamera", |
|
949 "FUNCTIONALITY", |
|
950 SetupL, UT_ChangeActiveCameraL, Teardown) |
|
951 |
|
952 EUNIT_END_TEST_TABLE |
|
953 |
|
954 // END OF FILE |
|
955 |
|
956 |
|