--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraxui/cxengine/tsrc/cxeenginetest.cpp Fri Apr 16 14:51:30 2010 +0300
@@ -0,0 +1,414 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+ #include <QTest>
+#include <QSignalSpy>
+#include "cxutils.h"
+#include "cxeenginetest.h"
+#include "cxeengine.h"
+#include "cxecameradevicecontrol.h"
+#include "cxestillcapturecontrol.h"
+#include "cxevideocapturecontrol.h"
+#include "cxeviewfindercontrol.h"
+#include "cxeautofocuscontrol.h"
+#include "cxeerror.h"
+
+using namespace Cxe;
+
+/**
+ * void TestCxeEngine::init()
+ * Helper function to initialize the engine.
+ * Run at the start of each test case.
+ */
+void TestCxeEngine::init()
+{
+ // Commented out because engine deletion fails -> engine created only once
+ // mEngine = CxeEngine::createEngine();
+}
+
+/**
+ * void TestCxeEngine::initTestCase()
+ * Tests that the engine initialization works properly
+ */
+void TestCxeEngine::initTestCase()
+{
+ mWindow = new HbMainWindow();
+ mEngine = CxeEngine::createEngine();
+
+ mWindow->setOrientation(Qt::Horizontal);
+ mWindow->showFullScreen();
+
+ // For viewfinder to be started, window needs to be set
+ mEngine->viewfinderControl().setWindow( mWindow->effectiveWinId());
+}
+
+/**
+ * Cleans up the engine.
+ * Run after each test case.
+ */
+void TestCxeEngine::cleanup()
+{
+ // commented out because engine delete fails
+ // delete mEngine;
+ // mEngine = NULL;
+}
+
+/**
+ * void TestCxeEngine::cleanupTestCase()
+ * Cleans up the engine and rest of the test environment.
+ * NOTE: This should be the last test case to be executed
+ */
+void TestCxeEngine::cleanupTestCase()
+{
+ delete mEngine;
+ mEngine = NULL;
+ delete mWindow;
+ mWindow = NULL;
+}
+
+/**
+ * void TestCxeEngine::createAndDestroyEngine()
+ * Tests that the engine construction and deletion works without errors.
+ */
+void TestCxeEngine::createAndDestroyEngine()
+{
+ // Do nothing here... just test that we can create and delete the engine
+ // instance without problems.
+ QVERIFY( mEngine != NULL );
+}
+
+/**
+ * void TestCxeEngine::initStillImageMode()
+ * Initializes the still image mode.
+ * NOTE: No initialization and cleanup, so that it can be used in test cases
+ * requiring still image mode to be ready.
+ */
+void TestCxeEngine::initStillImageMode()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+ CxeCameraDeviceControl &deviceControl = mEngine->cameraDeviceControl();
+ CxeStillCaptureControl &stillCaptureControl = mEngine->stillCaptureControl();
+
+ QSignalSpy deviceStateSpy(&deviceControl, SIGNAL(initModeComplete(CxeError::Id)));
+ QSignalSpy stillStateSpy(&stillCaptureControl, SIGNAL(stateChanged(CxeStillCaptureControl::State, CxeError::Id)));
+
+ // Check that the signals were connected withtout errors
+ QVERIFY( deviceStateSpy.isValid() );
+ QVERIFY( stillStateSpy.isValid() );
+
+ if (stillCaptureControl.state()!=CxeStillCaptureControl::Ready) {
+ mEngine->initMode(ImageMode);
+
+ // Wait for a maximum of 7 seconds for the operation to finish
+ int waitCount = 0;
+ while (deviceStateSpy.count() < 1) {
+ QTest::qWait(1000); // wait one second
+ waitCount++;
+ if (waitCount >= 7) {
+ QFAIL("initModeComplete timed out");
+ }
+ }
+
+ // Wait for any unexpected extra signals
+ QTest::qWait(2000);
+
+ // Check signal lists... Expect exactly one initModeComplete signal
+ QCOMPARE( deviceStateSpy.count(), 1 );
+
+ // Expect zero error code
+ QList<QVariant> initModeArguments = deviceStateSpy.takeFirst();
+ QVERIFY( initModeArguments.at(0).toInt() == 0 ); // CxeError::None
+
+ // Check signal changes for still capture control
+ // Just 1 state change signal expected: (Uninitialized ->) Ready
+ /*
+ int count = stillStateSpy.count();
+ for (int i=0; i<count ; i++) {
+ QList<QVariant> capArgs = stillStateSpy.takeAt(0);
+ qDebug("State:%d, err:%d", capArgs.at(0).value<CxeStillCaptureControl::State> (),
+ capArgs.at(1).toInt());
+ }
+ */
+
+ QCOMPARE( stillStateSpy.count(), 1 );
+ QList<QVariant> initArgs = stillStateSpy.takeFirst();
+ QVERIFY( initArgs.at(0).value<CxeStillCaptureControl::State>() == CxeStillCaptureControl::Ready );
+ QVERIFY( initArgs.at(1).toInt() == 0 );
+
+ //! @todo: check devicecontrolstate and stillcapturestate
+ }
+
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+/**
+ * void TestCxeEngine::testAutoFocusBasic()
+ * Test that AF either succeeds or fails when attempted.
+ */
+void TestCxeEngine::testAutoFocusBasic()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+
+ // Initialize before every test case
+ init();
+
+ // Initialize still mode - other details tested internally
+ initStillImageMode();
+
+ // Actual test of autofocus
+ CxeAutoFocusControl &afControl = mEngine->autoFocusControl();
+ QSignalSpy afDeviceStateSpy(&afControl, SIGNAL(stateChanged(CxeAutoFocusControl::State, CxeError::Id)) );
+ QVERIFY( afDeviceStateSpy.isValid() );
+
+ // Wait half a second before starting AF
+ QTest::qWait(500);
+ afControl.start();
+ QTest::qWait(3000);
+ afControl.cancel();
+
+ // Wait for signals
+ QTest::qWait(2000);
+ qDebug("AF signals:%d", afDeviceStateSpy.count());
+
+ int count = afDeviceStateSpy.count();
+ for (int i=0; i<count; i++) {
+ QList<QVariant> afArgs = afDeviceStateSpy.takeAt(0);
+ qDebug("State:%d, err:%d", afArgs.at(0).value<CxeAutoFocusControl::State> (),
+ afArgs.at(1).toInt());
+ }
+
+ /*
+ QCOMPARE( afDeviceStateSpy.count(), 2 );
+
+ QList<QVariant> afArguments = afDeviceStateSpy.takeAt(0);
+ QVERIFY( afArguments.at(0).value<CxeAutoFocusControl::State>() == CxeAutoFocusControl::InProgress );
+ QVERIFY( afArguments.at(1).toInt() == 0 );
+
+ afArguments = afDeviceStateSpy.takeAt(0);
+ QVERIFY( afArguments.at(0).value<CxeAutoFocusControl::State>() == CxeAutoFocusControl::Ready ||
+ afArguments.at(0).value<CxeAutoFocusControl::State>() == CxeAutoFocusControl::Failed );
+ QVERIFY( afArguments.at(1).toInt() == 0 );
+ */
+
+ // Cleanup after every test case
+ cleanup();
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+/**
+ * void TestCxeEngine::testImageCapture()
+ * Tests that image capture works properly.
+ */
+void TestCxeEngine::testImageCapture()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+ // Initialize before every test case
+ init();
+
+ // Initialize still mode - other details tested internally
+ initStillImageMode();
+
+ // Init signal spy for still capture control
+ CxeStillCaptureControl &stillCaptureControl = mEngine->stillCaptureControl();
+ QSignalSpy stillStateSpy(&stillCaptureControl, SIGNAL(stateChanged(CxeStillCaptureControl::State, CxeError::Id)));
+ QSignalSpy stillSnapSpy(&stillCaptureControl, SIGNAL(snapshotReady(int, CxeError::Id)));
+ QSignalSpy stillImageSpy(&stillCaptureControl, SIGNAL(imageCaptured(CxeError::Id)));
+
+ // Check that the signals were connected withtout errors
+ QVERIFY( stillStateSpy.isValid() );
+ QVERIFY( stillSnapSpy.isValid() );
+ QVERIFY( stillImageSpy.isValid() );
+
+ // Wait half a second before starting capture
+ CX_DEBUG(("Waiting before starting capture"));
+ QTest::qWait(500);
+ stillCaptureControl.capture();
+ CX_DEBUG(("Capture command executed"));
+
+ // Wait for signals and saving to complete
+ QTest::qWait(5000);
+
+ // Confirm that one snapshot signal and one image captured signal are received
+ QCOMPARE( stillSnapSpy.count(), 1 );
+ QCOMPARE( stillImageSpy.count(), 1 );
+
+ // 2 Signal expected: Capturing -> Ready/Uninitialized
+ qDebug("Still capture control state signals:%d", stillStateSpy.count());
+ QCOMPARE( stillStateSpy.count(), 2 );
+
+ QList<QVariant> capArguments = stillStateSpy.takeAt(0);
+ QVERIFY( capArguments.at(0).value<CxeStillCaptureControl::State>() == CxeStillCaptureControl::Capturing );
+ QVERIFY( capArguments.at(1).toInt() == 0 );
+
+ capArguments = stillStateSpy.takeAt(0);
+ QVERIFY( capArguments.at(0).value<CxeStillCaptureControl::State>() == CxeStillCaptureControl::Ready );
+ QVERIFY( capArguments.at(1).toInt() == 0 );
+
+ // Cleanup after every test case
+ cleanup();
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+/**
+ * void TestCxeEngine::testBatchCapture()
+ * Test that a number of images can be captured.
+ */
+void TestCxeEngine::testBatchCapture()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+ for(int i=0; i<3; i++) {
+ testImageCapture();
+ mEngine->stillCaptureControl().reset();
+ }
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+/**
+ * void TestCxeEngine::initVideoMode()
+ * Initializes the video mode.
+ * NOTE: No initialization and cleanup in done here, so that it can be used in
+ * test cases requiring video mode to be ready.
+ */
+void TestCxeEngine::initVideoMode()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+
+ QSignalSpy deviceStateSpy(&mEngine->videoCaptureControl(), SIGNAL(stateChanged(CxeVideoCaptureControl::State, CxeError::Id)));
+ QVERIFY( deviceStateSpy.isValid() );
+
+ if (mEngine->videoCaptureControl().state()!=CxeVideoCaptureControl::Ready) {
+ // Call initialize and wait 500ms for signals
+ mEngine->initMode(VideoMode);
+ QTest::qWait(500);
+
+ // 3 state change signals expected: Open -> Preparing -> Ready
+ QCOMPARE( deviceStateSpy.count(), 3 );
+
+ /*
+ int count = deviceStateSpy.count()
+ for (int i=0; i<count ; i++) {
+ QList<QVariant> capArgs = deviceStateSpy.takeAt(0);
+ qDebug("State:%d, err:%d", capArgs.at(0).value<CxeVideoCaptureControl::State> (),
+ capArgs.at(1).toInt());
+ }
+ */
+
+ QList<QVariant> initArgs = deviceStateSpy.takeAt(0);
+ QVERIFY(initArgs.at(0).value<CxeVideoCaptureControl::State>() == CxeVideoCaptureControl::Initialized);
+ QVERIFY( initArgs.at(1).toInt() == 0 );
+
+ initArgs = deviceStateSpy.takeAt(0);
+ QVERIFY( initArgs.at(0).value<CxeVideoCaptureControl::State>() == CxeVideoCaptureControl::Preparing );
+ QVERIFY( initArgs.at(1).toInt() == 0 );
+
+ initArgs = deviceStateSpy.takeAt(0);
+ QVERIFY( initArgs.at(0).value<CxeVideoCaptureControl::State>() == CxeVideoCaptureControl::Ready );
+ QVERIFY( initArgs.at(1).toInt() == 0 );
+ }
+
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+/**
+ * void TestCxeEngine::testVideoCapture()
+ * Tests that video capture works properly.
+ */
+void TestCxeEngine::testVideoCapture()
+{
+ CX_DEBUG_ENTER_FUNCTION();
+
+ // Initialize before every test case
+ init();
+
+ // Initialize the video mode
+ initVideoMode();
+
+ // Init signal spy for still capture control
+ CxeVideoCaptureControl &videoCaptureControl = mEngine->videoCaptureControl();
+ QSignalSpy videoStateSpy(&videoCaptureControl, SIGNAL(stateChanged(CxeVideoCaptureControl::State, CxeError::Id)));
+ QSignalSpy videoSnapSpy(&videoCaptureControl, SIGNAL(snapshotReady(CxeError::Id)));
+ QSignalSpy videoSpy(&videoCaptureControl, SIGNAL(videoComposed()));
+
+ // Check that the signals were connected withtout errors
+ QVERIFY( videoStateSpy.isValid() );
+ QVERIFY( videoSnapSpy.isValid() );
+ QVERIFY( videoSpy.isValid() );
+
+ // Wait half a second before starting recording
+ QTest::qWait(500);
+ videoCaptureControl.record();
+
+ // Wait for 2 seconds before stopping video
+ QTest::qWait(2000);
+ videoCaptureControl.stop();
+
+ // Wait some time for video to stop and signals to arrive
+ QTest::qWait(2000);
+
+ // Expected state sequence: PlayingStartSound -> Recording -> Stopping -> Idle/Ready
+ qDebug("Video capture control state signals:%d", videoStateSpy.count());
+ QCOMPARE(videoStateSpy.count(), 4);
+
+ QList<QVariant> stateArgs = videoStateSpy.takeAt(0);
+ QVERIFY( stateArgs.at(0).value<CxeVideoCaptureControl::State>() == CxeVideoCaptureControl::PlayingStartSound );
+ QVERIFY( stateArgs.at(1).toInt() == 0 );
+
+ stateArgs = videoStateSpy.takeAt(0);
+ QVERIFY( stateArgs.at(0).value<CxeVideoCaptureControl::State>() == CxeVideoCaptureControl::Recording );
+ QVERIFY( stateArgs.at(1).toInt() == 0 );
+
+ stateArgs = videoStateSpy.takeAt(0);
+ QVERIFY( stateArgs.at(0).value<CxeVideoCaptureControl::State>() == CxeVideoCaptureControl::Stopping );
+ QVERIFY( stateArgs.at(1).toInt() == 0 );
+
+ stateArgs = videoStateSpy.takeAt(0);
+ QVERIFY( stateArgs.at(0).value<CxeVideoCaptureControl::State>() == CxeVideoCaptureControl::Idle );
+ QVERIFY( stateArgs.at(1).toInt() == 0 );
+
+ /*
+ int count = videoStateSpy.count();
+ for (int i=0; i<count; i++) {
+ QList<QVariant> capArgs = videoStateSpy.takeAt(0);
+ qDebug("State:%d, err:%d", capArgs.at(0).value<CxeVideoCaptureControl::State> (),
+ capArgs.at(1).toInt());
+ }
+ */
+
+ // Confirm that one snapshot signal and one video composed signal is received
+ QCOMPARE( videoSnapSpy.count(), 1 );
+ QCOMPARE( videoSpy.count(), 1 );
+
+ // Cleanup after every test case
+ cleanup();
+ CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*
+void TestCxeEngine::testTemplate()
+{
+ // Initialize before every test case
+ init();
+
+ // Initialize the image mode
+ initTestCase();
+
+ // Cleanup after every test case
+ cleanup();
+}
+*/
+
+// main() function non-GUI testing
+QTEST_MAIN( TestCxeEngine );