Update to unit test

src/MissionManager/MissionManager.cc

@@ -27,6 +27,7 @@ MissionManager::MissionManager(Vehicle* vehicle)
     , _readTransactionInProgress(false)
     , _writeTransactionInProgress(false)
     , _resumeMission(false)
+    , _lastMissionRequest(-1)
     , _currentMissionIndex(-1)
     , _lastCurrentIndex(-1)
 {
@@ -46,6 +47,8 @@ MissionManager::~MissionManager()
 
 void MissionManager::_writeMissionItemsWorker(void)
 {
+    _lastMissionRequest = -1;
+
     emit newMissionItemsAvailable(_missionItems.count() == 0);
 
     qCDebug(MissionManagerLog) << "writeMissionItems count:" << _missionItems.count();
@@ -512,6 +515,7 @@ void MissionManager::_handleMissionRequest(const mavlink_message_t& message, boo
     
     mavlink_msg_mission_request_decode(&message, &missionRequest);
 
+    _lastMissionRequest = missionRequest.seq;
     if (!_itemIndicesToWrite.contains(missionRequest.seq)) {
         if (missionRequest.seq > _missionItems.count()) {
             _sendError(RequestRangeError, QString("Vehicle requested item outside range, count:request %1:%2. Send to Vehicle failed.").arg(_missionItems.count()).arg(missionRequest.seq));
@@ -637,7 +641,7 @@ void MissionManager::_handleMissionAck(const mavlink_message_t& message)
             qCDebug(MissionManagerLog) << "_handleMissionAck guided mode item accepted";
             _finishTransaction(true);
         } else {
-            _sendError(VehicleError, QString("Vehicle returned error: %1. Vehicle did not accept guided item.").arg(_missionResultToString((MAV_MISSION_RESULT)missionAck.type)));
+            _sendError(VehicleError, QString("Vehicle returned error: %1. %2Vehicle did not accept guided item.").arg(_missionResultToString((MAV_MISSION_RESULT)missionAck.type)));
             _finishTransaction(false);
         }
         break;
@@ -708,58 +712,97 @@ QString MissionManager::_ackTypeToString(AckType_t ackType)
     }
 }
 
+QString MissionManager::_lastMissionReqestString(MAV_MISSION_RESULT result)
+{
+    if (_lastMissionRequest != -1 && _lastMissionRequest >= 0 && _lastMissionRequest < _missionItems.count()) {
+        MissionItem* item = _missionItems[_lastMissionRequest];
+
+        switch (result) {
+        case MAV_MISSION_UNSUPPORTED_FRAME:
+            return QString(". Frame: %1").arg(item->frame());
+        case MAV_MISSION_UNSUPPORTED:
+            return QString(". Command: %1").arg(item->command());
+        case MAV_MISSION_INVALID_PARAM1:
+            return QString(". Param1: %1").arg(item->param1());
+        case MAV_MISSION_INVALID_PARAM2:
+            return QString(". Param2: %1").arg(item->param2());
+        case MAV_MISSION_INVALID_PARAM3:
+            return QString(". Param3: %1").arg(item->param3());
+        case MAV_MISSION_INVALID_PARAM4:
+            return QString(". Param4: %1").arg(item->param4());
+        case MAV_MISSION_INVALID_PARAM5_X:
+            return QString(". Param5: %1").arg(item->param5());
+        case MAV_MISSION_INVALID_PARAM6_Y:
+            return QString(". Param6: %1").arg(item->param6());
+        case MAV_MISSION_INVALID_PARAM7:
+            return QString(". Param7: %1").arg(item->param7());
+        case MAV_MISSION_INVALID_SEQUENCE:
+            return QString(". Sequence: %1").arg(item->sequenceNumber());
+        default:
+            break;
+        }
+    }
+
+    return QString();
+}
+
 QString MissionManager::_missionResultToString(MAV_MISSION_RESULT result)
 {
+    QString resultString;
+    QString lastRequestString = _lastMissionReqestString(result);
+
     switch (result) {
     case MAV_MISSION_ACCEPTED:
-        return QString("Mission accepted (MAV_MISSION_ACCEPTED)");
+        resultString = QString("Mission accepted (MAV_MISSION_ACCEPTED)");
         break;
     case MAV_MISSION_ERROR:
-        return QString("Unspecified error (MAV_MISSION_ERROR)");
+        resultString = QString("Unspecified error (MAV_MISSION_ERROR)");
         break;
     case MAV_MISSION_UNSUPPORTED_FRAME:
-        return QString("Coordinate frame is not supported (MAV_MISSION_UNSUPPORTED_FRAME)");
+        resultString = QString("Coordinate frame is not supported (MAV_MISSION_UNSUPPORTED_FRAME)");
         break;
     case MAV_MISSION_UNSUPPORTED:
-        return QString("Command is not supported (MAV_MISSION_UNSUPPORTED)");
+        resultString = QString("Command is not supported (MAV_MISSION_UNSUPPORTED)");
         break;
     case MAV_MISSION_NO_SPACE:
-        return QString("Mission item exceeds storage space (MAV_MISSION_NO_SPACE)");
+        resultString = QString("Mission item exceeds storage space (MAV_MISSION_NO_SPACE)");
         break;
     case MAV_MISSION_INVALID:
-        return QString("One of the parameters has an invalid value (MAV_MISSION_INVALID)");
+        resultString = QString("One of the parameters has an invalid value (MAV_MISSION_INVALID)");
         break;
     case MAV_MISSION_INVALID_PARAM1:
-        return QString("Param1 has an invalid value (MAV_MISSION_INVALID_PARAM1)");
+        resultString = QString("Param1 has an invalid value (MAV_MISSION_INVALID_PARAM1)");
         break;
     case MAV_MISSION_INVALID_PARAM2:
-        return QString("Param2 has an invalid value (MAV_MISSION_INVALID_PARAM2)");
+        resultString = QString("Param2 has an invalid value (MAV_MISSION_INVALID_PARAM2)");
         break;
     case MAV_MISSION_INVALID_PARAM3:
-        return QString("param3 has an invalid value (MAV_MISSION_INVALID_PARAM3)");
+        resultString = QString("Param3 has an invalid value (MAV_MISSION_INVALID_PARAM3)");
         break;
     case MAV_MISSION_INVALID_PARAM4:
-        return QString("Param4 has an invalid value (MAV_MISSION_INVALID_PARAM4)");
+        resultString = QString("Param4 has an invalid value (MAV_MISSION_INVALID_PARAM4)");
         break;
     case MAV_MISSION_INVALID_PARAM5_X:
-        return QString("X/Param5 has an invalid value (MAV_MISSION_INVALID_PARAM5_X)");
+        resultString = QString("X/Param5 has an invalid value (MAV_MISSION_INVALID_PARAM5_X)");
         break;
     case MAV_MISSION_INVALID_PARAM6_Y:
-        return QString("Y/Param6 has an invalid value (MAV_MISSION_INVALID_PARAM6_Y)");
+        resultString = QString("Y/Param6 has an invalid value (MAV_MISSION_INVALID_PARAM6_Y)");
         break;
     case MAV_MISSION_INVALID_PARAM7:
-        return QString("Param7 has an invalid value (MAV_MISSION_INVALID_PARAM7)");
+        resultString = QString("Param7 has an invalid value (MAV_MISSION_INVALID_PARAM7)");
         break;
     case MAV_MISSION_INVALID_SEQUENCE:
-        return QString("Received mission item out of sequence (MAV_MISSION_INVALID_SEQUENCE)");
+        resultString = QString("Received mission item out of sequence (MAV_MISSION_INVALID_SEQUENCE)");
         break;
     case MAV_MISSION_DENIED:
-        return QString("Not accepting any mission commands (MAV_MISSION_DENIED)");
+        resultString = QString("Not accepting any mission commands (MAV_MISSION_DENIED)");
         break;
     default:
         qWarning(MissionManagerLog) << "Fell off end of switch statement";
-        return QString("QGC Internal Error");
+        resultString = QString("QGC Internal Error");
     }
+
+    return resultString + lastRequestString;
 }
 
 void MissionManager::_finishTransaction(bool success)

src/MissionManager/MissionManager.h

@@ -116,6 +116,7 @@ private:
     void _writeMissionCount(void);
     void _writeMissionItemsWorker(void);
     void _clearAndDeleteMissionItems(void);
+    QString _lastMissionReqestString(MAV_MISSION_RESULT result);
 
 private:
     Vehicle*            _vehicle;
@@ -130,6 +131,7 @@ private:
     bool        _resumeMission;
     QList<int>  _itemIndicesToWrite;    ///< List of mission items which still need to be written to vehicle
     QList<int>  _itemIndicesToRead;     ///< List of mission items which still need to be requested from vehicle
+    int         _lastMissionRequest;    ///< Index of item last requested by MISSION_REQUEST
     
     QMutex _dataMutex;
     

src/MissionManager/SurveyMissionItem.cc

@@ -120,6 +120,8 @@ SurveyMissionItem::SurveyMissionItem(Vehicle* vehicle, QObject* parent)
 
     connect(&_gridAltitudeFact,                 &Fact::valueChanged, this, &SurveyMissionItem::_updateCoordinateAltitude);
 
+    connect(&_gridAltitudeRelativeFact,         &Fact::valueChanged, this, &SurveyMissionItem::_setDirty);
+
     // Signal to Qml when camera value changes so it can recalc
     connect(&_groundResolutionFact,             &Fact::valueChanged, this, &SurveyMissionItem::_cameraValueChanged);
     connect(&_frontalOverlapFact,               &Fact::valueChanged, this, &SurveyMissionItem::_cameraValueChanged);
@@ -562,6 +564,7 @@ void SurveyMissionItem::_updateCoordinateAltitude(void)
     _exitCoordinate.setAltitude(_gridAltitudeFact.rawValue().toDouble());
     emit coordinateChanged(_coordinate);
     emit exitCoordinateChanged(_exitCoordinate);
+    setDirty(true);
 }
 
 QPointF SurveyMissionItem::_rotatePoint(const QPointF& point, const QPointF& origin, double angle)

src/MissionManager/SurveyMissionItem.h

@@ -58,13 +58,6 @@ public:
 
     Q_PROPERTY(QGCMapPolygon*       mapPolygon                  READ mapPolygon                     CONSTANT)
 
-#if 0
-    // The polygon vertices are also exposed as a list mode since MapItemView will only work with a QAbstractItemModel as
-    // opposed to polygonPath which is a QVariantList.
-    Q_PROPERTY(QmlObjectListModel*  polygonModel                READ polygonModel                   CONSTANT)
-    Q_PROPERTY(QVariantList         polygonPath                 READ polygonPath                    NOTIFY polygonPathChanged)
-#endif
-
     QVariantList gridPoints (void) { return _simpleGridPoints; }
 
     Fact* manualGrid                (void) { return &_manualGridFact; }
@@ -160,7 +153,6 @@ public:
     static const char* cameraName;
 
 signals:
-    void polygonPathChanged             (void);
     void gridPointsChanged              (void);
     void cameraShotsChanged             (int cameraShots);
     void coveredAreaChanged             (double coveredArea);

src/MissionManager/SurveyMissionItemTest.cc

@@ -7,10 +7,11 @@
  *
  ****************************************************************************/
 
-
 #include "SurveyMissionItemTest.h"
+#include "QGCApplication.h"
 
 SurveyMissionItemTest::SurveyMissionItemTest(void)
+    : _offlineVehicle(NULL)
 {
     _polyPoints << QGeoCoordinate(47.633550640000003, -122.08982199) << QGeoCoordinate(47.634129020000003, -122.08887249) <<
                    QGeoCoordinate(47.633619320000001, -122.08811074) << QGeoCoordinate(47.633189139999999, -122.08900124);
@@ -18,34 +19,20 @@ SurveyMissionItemTest::SurveyMissionItemTest(void)
 
 void SurveyMissionItemTest::init(void)
 {
-    _rgComplexMissionItemSignals[polygonPathChangedIndex] =         SIGNAL(polygonPathChanged());
-    _rgComplexMissionItemSignals[lastSequenceNumberChangedIndex] =  SIGNAL(lastSequenceNumberChanged(int));
-    _rgComplexMissionItemSignals[altitudeChangedIndex] =            SIGNAL(altitudeChanged(double));
-    _rgComplexMissionItemSignals[gridAngleChangedIndex] =           SIGNAL(gridAngleChanged(double));
-    _rgComplexMissionItemSignals[gridPointsChangedIndex] =          SIGNAL(gridPointsChanged());
-    _rgComplexMissionItemSignals[cameraTriggerChangedIndex] =       SIGNAL(cameraTriggerChanged(bool));
-
-    _rgComplexMissionItemSignals[altDifferenceChangedIndex] =           SIGNAL(altDifferenceChanged(double));
-    _rgComplexMissionItemSignals[altPercentChangedIndex] =              SIGNAL(altPercentChanged(double));
-    _rgComplexMissionItemSignals[azimuthChangedIndex] =                 SIGNAL(azimuthChanged(double));
-    _rgComplexMissionItemSignals[commandDescriptionChangedIndex] =      SIGNAL(commandDescriptionChanged());
-    _rgComplexMissionItemSignals[commandNameChangedIndex] =             SIGNAL(commandNameChanged());
-    _rgComplexMissionItemSignals[abbreviationChangedIndex] =            SIGNAL(abbreviationChanged());
-    _rgComplexMissionItemSignals[coordinateChangedIndex] =              SIGNAL(coordinateChanged(const QGeoCoordinate&));
-    _rgComplexMissionItemSignals[exitCoordinateChangedIndex] =          SIGNAL(exitCoordinateChanged(const QGeoCoordinate&));
-    _rgComplexMissionItemSignals[dirtyChangedIndex] =                   SIGNAL(dirtyChanged(bool));
-    _rgComplexMissionItemSignals[distanceChangedIndex] =                SIGNAL(distanceChanged(double));
-    _rgComplexMissionItemSignals[isCurrentItemChangedIndex] =           SIGNAL(isCurrentItemChanged(bool));
-    _rgComplexMissionItemSignals[sequenceNumberChangedIndex] =          SIGNAL(sequenceNumberChanged(int));
-    _rgComplexMissionItemSignals[isSimpleItemChangedIndex] =            SIGNAL(isSimpleItemChanged(bool));
-    _rgComplexMissionItemSignals[specifiesCoordinateChangedIndex] =     SIGNAL(specifiesCoordinateChanged());
-    _rgComplexMissionItemSignals[isStandaloneCoordinateChangedIndex] =  SIGNAL(isStandaloneCoordinateChanged());
-
-    _rgComplexMissionItemSignals[coordinateHasRelativeAltitudeChangedIndex] =       SIGNAL(coordinateHasRelativeAltitudeChanged(bool));
-    _rgComplexMissionItemSignals[exitCoordinateHasRelativeAltitudeChangedIndex] =   SIGNAL(exitCoordinateHasRelativeAltitudeChanged(bool));
-    _rgComplexMissionItemSignals[exitCoordinateSameAsEntryChangedIndex] =           SIGNAL(exitCoordinateSameAsEntryChanged(bool));
-
-    _surveyItem = new SurveyMissionItem(NULL /* Vehicle */, this);
+    UnitTest::init();
+
+    _rgSurveySignals[gridPointsChangedIndex] =              SIGNAL(gridPointsChanged());
+    _rgSurveySignals[cameraShotsChangedIndex] =             SIGNAL(cameraShotsChanged(int));
+    _rgSurveySignals[coveredAreaChangedIndex] =             SIGNAL(coveredAreaChanged(double));
+    _rgSurveySignals[cameraValueChangedIndex] =             SIGNAL(cameraValueChanged());
+    _rgSurveySignals[gridTypeChangedIndex] =                SIGNAL(gridTypeChanged(QString));
+    _rgSurveySignals[timeBetweenShotsChangedIndex] =        SIGNAL(timeBetweenShotsChanged());
+    _rgSurveySignals[cameraOrientationFixedChangedIndex] =  SIGNAL(cameraOrientationFixedChanged(bool));
+    _rgSurveySignals[refly90DegreesChangedIndex] =          SIGNAL(refly90DegreesChanged(bool));
+    _rgSurveySignals[dirtyChangedIndex] =                   SIGNAL(dirtyChanged(bool));
+
+    _offlineVehicle = new Vehicle(MAV_AUTOPILOT_PX4, MAV_TYPE_QUADROTOR, qgcApp()->toolbox()->firmwarePluginManager(), this);
+    _surveyItem = new SurveyMissionItem(_offlineVehicle, this);
     _mapPolygon = _surveyItem->mapPolygon();
 
     // It's important to check that the right signals are emitted at the right time since that drives ui change.
@@ -54,12 +41,13 @@ void SurveyMissionItemTest::init(void)
 
     _multiSpy = new MultiSignalSpy();
     Q_CHECK_PTR(_multiSpy);
-    QCOMPARE(_multiSpy->init(_surveyItem, _rgComplexMissionItemSignals, _cComplexMissionItemSignals), true);
+    QCOMPARE(_multiSpy->init(_surveyItem, _rgSurveySignals, _cSurveySignals), true);
 }
 
 void SurveyMissionItemTest::cleanup(void)
 {
     delete _surveyItem;
+    delete _offlineVehicle;
     delete _multiSpy;
 }
 
@@ -69,17 +57,93 @@ void SurveyMissionItemTest::_testDirty(void)
     _surveyItem->setDirty(false);
     QVERIFY(!_surveyItem->dirty());
     QVERIFY(_multiSpy->checkNoSignals());
+
     _surveyItem->setDirty(true);
     QVERIFY(_surveyItem->dirty());
     QVERIFY(_multiSpy->checkOnlySignalByMask(dirtyChangedMask));
     QVERIFY(_multiSpy->pullBoolFromSignalIndex(dirtyChangedIndex));
     _multiSpy->clearAllSignals();
+
     _surveyItem->setDirty(false);
     QVERIFY(!_surveyItem->dirty());
     QVERIFY(_multiSpy->checkOnlySignalByMask(dirtyChangedMask));
     QVERIFY(!_multiSpy->pullBoolFromSignalIndex(dirtyChangedIndex));
+    _multiSpy->clearAllSignals();
+
+    // These facts should set dirty when changed
+    QList<Fact*> rgFacts;
+    rgFacts << _surveyItem->gridAltitude() << _surveyItem->gridAngle() << _surveyItem->gridSpacing() << _surveyItem->turnaroundDist() << _surveyItem->cameraTriggerDistance() <<
+               _surveyItem->gridAltitudeRelative() << _surveyItem->cameraTriggerInTurnaround() << _surveyItem->hoverAndCapture();
+    foreach(Fact* fact, rgFacts) {
+        qDebug() << fact->name();
+        QVERIFY(!_surveyItem->dirty());
+        if (fact->typeIsBool()) {
+            fact->setRawValue(!fact->rawValue().toBool());
+        } else {
+            fact->setRawValue(fact->rawValue().toDouble() + 1);
+        }
+        QVERIFY(_multiSpy->checkSignalByMask(dirtyChangedMask));
+        QVERIFY(_multiSpy->pullBoolFromSignalIndex(dirtyChangedIndex));
+        _surveyItem->setDirty(false);
+        _multiSpy->clearAllSignals();
+    }
+    rgFacts.clear();
+
+    // These facts should not change dirty bit
+    rgFacts << _surveyItem->groundResolution() << _surveyItem->frontalOverlap() << _surveyItem->sideOverlap() << _surveyItem->cameraSensorWidth() << _surveyItem->cameraSensorHeight() <<
+               _surveyItem->cameraResolutionWidth() << _surveyItem->cameraResolutionHeight() << _surveyItem->cameraFocalLength() << _surveyItem->cameraOrientationLandscape() <<
+                _surveyItem->fixedValueIsAltitude() << _surveyItem->camera() << _surveyItem->manualGrid();
+    foreach(Fact* fact, rgFacts) {
+        qDebug() << fact->name();
+        QVERIFY(!_surveyItem->dirty());
+        if (fact->typeIsBool()) {
+            fact->setRawValue(!fact->rawValue().toBool());
+        } else {
+            fact->setRawValue(fact->rawValue().toDouble() + 1);
+        }
+        QVERIFY(_multiSpy->checkNoSignalByMask(dirtyChangedMask));
+        QVERIFY(!_surveyItem->dirty());
+        _multiSpy->clearAllSignals();
+    }
+    rgFacts.clear();
+}
+
+void SurveyMissionItemTest::_testCameraValueChanged(void)
+{
+    // These facts should trigger cameraValueChanged when changed
+    QList<Fact*> rgFacts;
+    rgFacts << _surveyItem->groundResolution() << _surveyItem->frontalOverlap() << _surveyItem->sideOverlap() << _surveyItem->cameraSensorWidth() << _surveyItem->cameraSensorHeight() <<
+               _surveyItem->cameraResolutionWidth() << _surveyItem->cameraResolutionHeight() << _surveyItem->cameraFocalLength() << _surveyItem->cameraOrientationLandscape();
+    foreach(Fact* fact, rgFacts) {
+        qDebug() << fact->name();
+        if (fact->typeIsBool()) {
+            fact->setRawValue(!fact->rawValue().toBool());
+        } else {
+            fact->setRawValue(fact->rawValue().toDouble() + 1);
+        }
+        QVERIFY(_multiSpy->checkSignalByMask(cameraValueChangedMask));
+        _multiSpy->clearAllSignals();
+    }
+    rgFacts.clear();
+
+    // These facts should not trigger cameraValueChanged
+    rgFacts << _surveyItem->gridAltitude() << _surveyItem->gridAngle() << _surveyItem->gridSpacing() << _surveyItem->turnaroundDist() << _surveyItem->cameraTriggerDistance() <<
+               _surveyItem->gridAltitudeRelative() << _surveyItem->cameraTriggerInTurnaround() << _surveyItem->hoverAndCapture() <<
+               _surveyItem->fixedValueIsAltitude() << _surveyItem->camera() << _surveyItem->manualGrid();
+    foreach(Fact* fact, rgFacts) {
+        qDebug() << fact->name();
+        if (fact->typeIsBool()) {
+            fact->setRawValue(!fact->rawValue().toBool());
+        } else {
+            fact->setRawValue(fact->rawValue().toDouble() + 1);
+        }
+        QVERIFY(_multiSpy->checkNoSignalByMask(cameraValueChangedMask));
+        _multiSpy->clearAllSignals();
+    }
+    rgFacts.clear();
 }
 
+#if 0
 void SurveyMissionItemTest::_testAddPolygonCoordinate(void)
 {
     QCOMPARE(_mapPolygon->count(), 0);
@@ -210,3 +274,4 @@ void SurveyMissionItemTest::_testCameraTrigger(void)
     QVERIFY(_multiSpy->checkOnlySignalByMask(lastSequenceNumberChangedMask | dirtyChangedMask | cameraTriggerChangedMask));
     QCOMPARE(_multiSpy->pullIntFromSignalIndex(lastSequenceNumberChangedIndex), lastSeq);
 }
+#endif

src/MissionManager/SurveyMissionItemTest.h

@@ -18,7 +18,7 @@
 
 #include <QGeoCoordinate>
 
-/// Unit test for SimpleMissionItem
+/// Unit test for SurveyMissionItem
 class SurveyMissionItemTest : public UnitTest
 {
     Q_OBJECT
@@ -32,68 +32,43 @@ protected:
     
 private slots:
     void _testDirty(void);
+    void _testCameraValueChanged(void);
+#if 0
     void _testAddPolygonCoordinate(void);
     void _testClearPolygon(void);
     void _testCameraTrigger(void);
+#endif
 
 private:
     enum {
-        polygonPathChangedIndex = 0,
-        lastSequenceNumberChangedIndex,
-        altitudeChangedIndex,
-        gridAngleChangedIndex,
-        gridPointsChangedIndex,
-        cameraTriggerChangedIndex,
-        altDifferenceChangedIndex,
-        altPercentChangedIndex,
-        azimuthChangedIndex,
-        commandDescriptionChangedIndex,
-        commandNameChangedIndex,
-        abbreviationChangedIndex,
-        coordinateChangedIndex,
-        exitCoordinateChangedIndex,
+        gridPointsChangedIndex = 0,
+        cameraShotsChangedIndex,
+        coveredAreaChangedIndex,
+        cameraValueChangedIndex,
+        gridTypeChangedIndex,
+        timeBetweenShotsChangedIndex,
+        cameraOrientationFixedChangedIndex,
+        refly90DegreesChangedIndex,
         dirtyChangedIndex,
-        distanceChangedIndex,
-        isCurrentItemChangedIndex,
-        sequenceNumberChangedIndex,
-        isSimpleItemChangedIndex,
-        specifiesCoordinateChangedIndex,
-        isStandaloneCoordinateChangedIndex,
-        coordinateHasRelativeAltitudeChangedIndex,
-        exitCoordinateHasRelativeAltitudeChangedIndex,
-        exitCoordinateSameAsEntryChangedIndex,
         maxSignalIndex
     };
 
     enum {
-        polygonPathChangedMask =                        1 << polygonPathChangedIndex,
-        lastSequenceNumberChangedMask =                 1 << lastSequenceNumberChangedIndex,
-        altitudeChangedMask =                           1 << altitudeChangedIndex,
-        gridAngleChangedMask =                          1 << gridAngleChangedIndex,
         gridPointsChangedMask =             1 << gridPointsChangedIndex,
-        cameraTriggerChangedMask =                      1 << cameraTriggerChangedIndex,
-        altDifferenceChangedMask =                      1 << altDifferenceChangedIndex,
-        altPercentChangedMask =                         1 << altPercentChangedIndex,
-        azimuthChangedMask =                            1 << azimuthChangedIndex,
-        commandDescriptionChangedMask =                 1 << commandDescriptionChangedIndex,
-        commandNameChangedMask =                        1 << commandNameChangedIndex,
-        coordinateChangedMask =                         1 << coordinateChangedIndex,
-        exitCoordinateChangedMask =                     1 << exitCoordinateChangedIndex,
-        dirtyChangedMask =                              1 << dirtyChangedIndex,
-        distanceChangedMask =                           1 << distanceChangedIndex,
-        isCurrentItemChangedMask =                      1 << isCurrentItemChangedIndex,
-        sequenceNumberChangedMask =                     1 << sequenceNumberChangedIndex,
-        isSimpleItemChangedMask =                       1 << isSimpleItemChangedIndex,
-        specifiesCoordinateChangedMask =                1 << specifiesCoordinateChangedIndex,
-        isStandaloneCoordinateChangedMask =             1 << isStandaloneCoordinateChangedIndex,
-        coordinateHasRelativeAltitudeChangedMask =      1 << coordinateHasRelativeAltitudeChangedIndex,
-        exitCoordinateHasRelativeAltitudeChangedMask =  1 << exitCoordinateHasRelativeAltitudeChangedIndex,
-        exitCoordinateSameAsEntryChangedMask =          1 << exitCoordinateSameAsEntryChangedIndex,
+        cameraShotsChangedMask =            1 << cameraShotsChangedIndex,
+        coveredAreaChangedMask =            1 << coveredAreaChangedIndex,
+        cameraValueChangedMask =            1 << cameraValueChangedIndex,
+        gridTypeChangedMask =               1 << gridTypeChangedIndex,
+        timeBetweenShotsChangedMask =       1 << timeBetweenShotsChangedIndex,
+        cameraOrientationFixedChangedMask = 1 << cameraOrientationFixedChangedIndex,
+        refly90DegreesChangedMask =         1 << refly90DegreesChangedIndex,
+        dirtyChangedMask =                  1 << dirtyChangedIndex
     };
 
-    static const size_t _cComplexMissionItemSignals = maxSignalIndex;
-    const char*         _rgComplexMissionItemSignals[_cComplexMissionItemSignals];
+    static const size_t _cSurveySignals = maxSignalIndex;
+    const char*         _rgSurveySignals[_cSurveySignals];
 
+    Vehicle*                _offlineVehicle;
     MultiSignalSpy*         _multiSpy;
     SurveyMissionItem*      _surveyItem;
     QGCMapPolygon*          _mapPolygon;

src/qgcunittest/UnitTestList.cc

@@ -50,6 +50,7 @@ UT_REGISTER_TEST(ParameterManagerTest)
 UT_REGISTER_TEST(MissionCommandTreeTest)
 UT_REGISTER_TEST(LogDownloadTest)
 UT_REGISTER_TEST(SendMavCommandTest)
+UT_REGISTER_TEST(SurveyMissionItemTest)
 
 // List of unit test which are currently disabled.
 // If disabling a new test, include reason in comment.
@@ -61,5 +62,4 @@ UT_REGISTER_TEST(SendMavCommandTest)
 //UT_REGISTER_TEST(FileManagerTest)
 
 // Needs to be update for latest changes
-//UT_REGISTER_TEST(SurveyMissionItemTest)
 //UT_REGISTER_TEST(MavlinkLogTest)