diff -r f54ad444594d -r 61bc0f252b2b camerauis/cameraxui/cxengine/tsrc/cxeenginetest.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraxui/cxengine/tsrc/cxeenginetest.cpp	Tue Aug 31 15:03:46 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 );