Better debugging support

src/qgcunittest/MultiSignalSpy.cc

@@ -53,10 +53,9 @@ MultiSignalSpy::~MultiSignalSpy()
 /// Initializes the class. Must be called once before use.
 ///     @return true if success, false for failure
 
-bool MultiSignalSpy::init(
-                        QObject*        signalEmitter,  ///< [in] object which the signals are emitted from
-                        const char**    rgSignals,      ///< [in] array of signals to spy on
-                        size_t          cSignals)       ///< [in] numbers of signals in rgSignals
+bool MultiSignalSpy::init(QObject*        signalEmitter,    ///< [in] object which the signals are emitted from
+                          const char**    rgSignals,        ///< [in] array of signals to spy on
+                          size_t          cSignals)         ///< [in] numbers of signals in rgSignals
 {
     if (!signalEmitter || !rgSignals || cSignals == 0) {
         qDebug() << "Invalid arguments";
@@ -85,7 +84,7 @@ bool MultiSignalSpy::init(
     return true;
 }
 
-bool MultiSignalSpy::_checkSignalByMaskWorker(quint16 mask, bool multipleSignalsAllowed)
+bool MultiSignalSpy::_checkSignalByMaskWorker(quint32 mask, bool multipleSignalsAllowed)
 {
     for (size_t i=0; i<_cSignals; i++) {
         if ((1 << i) & mask) {
@@ -94,7 +93,7 @@ bool MultiSignalSpy::_checkSignalByMaskWorker(quint16 mask, bool multipleSignals
             
             if ((multipleSignalsAllowed && spy->count() ==  0) || (!multipleSignalsAllowed && spy->count() != 1)) {
                 qDebug() << "Failed index:" << i;
-                _printSignalState();
+                _printSignalState(mask);
                 return false;
             }
         }
@@ -103,7 +102,7 @@ bool MultiSignalSpy::_checkSignalByMaskWorker(quint16 mask, bool multipleSignals
     return true;
 }
 
-bool MultiSignalSpy::_checkOnlySignalByMaskWorker(quint16 mask, bool multipleSignalsAllowed)
+bool MultiSignalSpy::_checkOnlySignalByMaskWorker(quint32 mask, bool multipleSignalsAllowed)
 {
     for (size_t i=0; i<_cSignals; i++) {
         QSignalSpy* spy = _rgSpys[i];
@@ -111,12 +110,12 @@ bool MultiSignalSpy::_checkOnlySignalByMaskWorker(quint16 mask, bool multipleSig
 
         if ((1 << i) & mask) {
             if ((multipleSignalsAllowed && spy->count() ==  0) || (!multipleSignalsAllowed && spy->count() != 1)) {
-                _printSignalState();
+                _printSignalState(mask);
                 return false;
             }
         } else {
             if (spy->count() != 0) {
-                _printSignalState();
+                _printSignalState(mask);
                 return false;
             }
         }
@@ -125,28 +124,28 @@ bool MultiSignalSpy::_checkOnlySignalByMaskWorker(quint16 mask, bool multipleSig
     return true;
 }
 
-bool MultiSignalSpy::checkSignalByMask(quint16 mask)
+bool MultiSignalSpy::checkSignalByMask(quint32 mask)
 {
     return _checkSignalByMaskWorker(mask, false /* multipleSignalsAllowed */);
 }
 
-bool MultiSignalSpy::checkOnlySignalByMask(quint16 mask)
+bool MultiSignalSpy::checkOnlySignalByMask(quint32 mask)
 {
     return _checkOnlySignalByMaskWorker(mask, false /* multipleSignalsAllowed */);
 }
 
-bool MultiSignalSpy::checkSignalsByMask(quint16 mask)
+bool MultiSignalSpy::checkSignalsByMask(quint32 mask)
 {
     return _checkSignalByMaskWorker(mask, true /* multipleSignalsAllowed */);
 }
 
-bool MultiSignalSpy::checkOnlySignalsByMask(quint16 mask)
+bool MultiSignalSpy::checkOnlySignalsByMask(quint32 mask)
 {
     return _checkOnlySignalByMaskWorker(mask, true /* multipleSignalsAllowed */);
 }
 
 /// @return true if signal count = 0 for specified signals
-bool MultiSignalSpy::checkNoSignalByMask(quint16 mask)
+bool MultiSignalSpy::checkNoSignalByMask(quint32 mask)
 {
     for (size_t i=0; i<_cSignals; i++) {
         if ((1 << i) & mask) {
@@ -154,7 +153,7 @@ bool MultiSignalSpy::checkNoSignalByMask(quint16 mask)
             Q_ASSERT(spy != NULL);
 
             if (spy->count() != 0) {
-                _printSignalState();
+                _printSignalState(mask);
                 return false;
             }
         }
@@ -170,7 +169,7 @@ bool MultiSignalSpy::checkNoSignals(void)
 }
 
 /// @return QSignalSpy for the specified signal
-QSignalSpy* MultiSignalSpy::getSpyByIndex(quint16 index)
+QSignalSpy* MultiSignalSpy::getSpyByIndex(quint32 index)
 {
     Q_ASSERT(index < _cSignals);
     Q_ASSERT(_rgSpys[index] != NULL);
@@ -179,7 +178,7 @@ QSignalSpy* MultiSignalSpy::getSpyByIndex(quint16 index)
 }
 
 /// Sets the signal count to 0 for the specified signal
-void MultiSignalSpy::clearSignalByIndex(quint16 index)
+void MultiSignalSpy::clearSignalByIndex(quint32 index)
 {
     Q_ASSERT(index < _cSignals);
     Q_ASSERT(_rgSpys[index] != NULL);
@@ -188,7 +187,7 @@ void MultiSignalSpy::clearSignalByIndex(quint16 index)
 }
 
 /// Sets the signal count to 0 for all specified signals
-void MultiSignalSpy::clearSignalsByMask(quint16 mask)
+void MultiSignalSpy::clearSignalsByMask(quint32 mask)
 {
     for (size_t i=0; i<_cSignals; i++) {
         if ((1 << i) & mask) {
@@ -203,7 +202,7 @@ void MultiSignalSpy::clearSignalsByMask(quint16 mask)
 /// Sets the signal count to 0 for all signals
 void MultiSignalSpy::clearAllSignals(void)
 {
-    for (quint16 i=0;i<_cSignals; i++) {
+    for (quint32 i=0;i<_cSignals; i++) {
         clearSignalByIndex(i);
     }
 }
@@ -217,7 +216,7 @@ void MultiSignalSpy::timerEvent(QTimerEvent * event)
 /// Waits the specified signal
 ///     @return false for timeout
 bool MultiSignalSpy::waitForSignalByIndex(
-                                          quint16 index,  ///< [in] index of signal to wait on
+                                          quint32 index,  ///< [in] index of signal to wait on
                                           int     msec)   ///< [in] numbers of milleconds to wait before timeout, -1 wait forever
 {
     // Check input parameters
@@ -250,17 +249,31 @@ bool MultiSignalSpy::waitForSignalByIndex(
     return spy->count() != 0;
 }
 
-void MultiSignalSpy::_printSignalState(void)
+void MultiSignalSpy::_printSignalState(quint32 mask)
 {
     for (size_t i=0; i<_cSignals; i++) {
+        bool expected = (1 << i) & mask;
+
         QSignalSpy* spy = _rgSpys[i];
         Q_ASSERT(spy != NULL);
-        qDebug() << "Signal index:" << i << "count:" << spy->count();
+        qDebug() << "Signal index:" << i << "count:" << spy->count() << "expected:" << expected << _rgSignals[i];
     }
 }
 
-bool MultiSignalSpy::pullBoolFromSignalIndex(quint16 index)
+bool MultiSignalSpy::pullBoolFromSignalIndex(quint32 index)
 {
     QSignalSpy* spy = getSpyByIndex(index);
     return spy->value(0).value(0).toBool();
 }
+
+int MultiSignalSpy::pullIntFromSignalIndex(quint32 index)
+{
+    QSignalSpy* spy = getSpyByIndex(index);
+    return spy->value(0).value(0).toInt();
+}
+
+QGeoCoordinate MultiSignalSpy::pullQGeoCoordinateFromSignalIndex(quint32 index)
+{
+    QSignalSpy* spy = getSpyByIndex(index);
+    return spy->value(0).value(0).value<QGeoCoordinate>();
+}

src/qgcunittest/MultiSignalSpy.h

@@ -26,6 +26,7 @@
 
 #include <QObject>
 #include <QSignalSpy>
+#include <QGeoCoordinate>
 
 /// @file
 ///     @brief This class allows you to keep track of signal counts on a set of signals associated with an object.
@@ -46,42 +47,44 @@ public:
     /// @param mask bit mask specifying which signals to check. The lowest order bit represents
     ///     index 0 into the rgSignals array and so on up the bit mask.
     /// @return true if signal count = 1 for the specified signals
-    bool checkSignalByMask(quint16 mask);
+    bool checkSignalByMask(quint32 mask);
 
     /// @return true if signal count = 1 for specified signals and signal count of 0
     ///     for all other signals
-    bool checkOnlySignalByMask(quint16 mask);
+    bool checkOnlySignalByMask(quint32 mask);
 
     /// @param mask bit mask specifying which signals to check. The lowest order bit represents
     ///     index 0 into the rgSignals array and so on up the bit mask.
     /// @return true if signal count >= 1 for the specified signals
-    bool checkSignalsByMask(quint16 mask);
+    bool checkSignalsByMask(quint32 mask);
 
     /// @return true if signal count >= 1 for specified signals and signal count of 0
     ///     for all other signals
-    bool checkOnlySignalsByMask(quint16 mask);
+    bool checkOnlySignalsByMask(quint32 mask);
 
-    bool checkNoSignalByMask(quint16 mask);
+    bool checkNoSignalByMask(quint32 mask);
     bool checkNoSignals(void);
 
-    void clearSignalByIndex(quint16 index);
-    void clearSignalsByMask(quint16 mask);
+    void clearSignalByIndex(quint32 index);
+    void clearSignalsByMask(quint32 mask);
     void clearAllSignals(void);
 
-    bool waitForSignalByIndex(quint16 index, int msec);
+    bool waitForSignalByIndex(quint32 index, int msec);
     
-    QSignalSpy* getSpyByIndex(quint16 index);
+    QSignalSpy* getSpyByIndex(quint32 index);
+
+    // Returns the value type for the first parameter of the signal
+    bool pullBoolFromSignalIndex(quint32 index);
+    int pullIntFromSignalIndex(quint32 index);
+    QGeoCoordinate pullQGeoCoordinateFromSignalIndex(quint32 index);
 
-    /// Returns the boolean value for a signal which has a single bool param
-    bool pullBoolFromSignalIndex(quint16 index);
-    
 private:
     // QObject overrides
     void timerEvent(QTimerEvent * event);
     
-    void _printSignalState(void);
-    bool _checkSignalByMaskWorker(quint16 mask, bool multipleSignalsAllowed);
-    bool _checkOnlySignalByMaskWorker(quint16 mask, bool multipleSignalsAllowed);
+    void _printSignalState(quint32 mask);
+    bool _checkSignalByMaskWorker(quint32 mask, bool multipleSignalsAllowed);
+    bool _checkOnlySignalByMaskWorker(quint32 mask, bool multipleSignalsAllowed);
 
     QObject*        _signalEmitter;
     const char**    _rgSignals;