Rework call settings test

diff --git a/tests/test_ofonocallmeter.cpp b/tests/test_ofonocallmeter.cpp
index 00dfde9..405f7b5 100644 (file)
--- a/tests/test_ofonocallmeter.cpp
+++ b/tests/test_ofonocallmeter.cpp
@@ -63,6 +63,7 @@ private slots:
        QCOMPARE(list.at(1).toUInt(), uint(0));
        QCOMPARE(callMeterChanged.count(), 1);
        QCOMPARE(callMeterChanged.takeFirst().at(0).toUInt(), uint(0));
+       // should also test change in call meter as a result of voice call
     }
 
 

diff --git a/tests/test_ofonocallsettings.cpp b/tests/test_ofonocallsettings.cpp
index 7a08576..066f764 100644 (file)
--- a/tests/test_ofonocallsettings.cpp
+++ b/tests/test_ofonocallsettings.cpp
@@ -34,133 +34,116 @@ class TestOfonoCallSettings : public QObject
     Q_OBJECT
 
 private slots:
-
-    void validityChanged(bool validity)
-    {
-       qDebug() << "ValidityChanged" << validity;
-    }
-
-    void callingLinePresentationComplete(bool success, QString setting)
-    {
-       qDebug() << "callingLinePresentationComplete" << success << setting;
-    }
-    void calledLinePresentationComplete(bool success, QString setting)
-    {
-       qDebug() << "calledLinePresentationComplete" << success << setting;
-    }
-    void calledLineRestrictionComplete(bool success, QString setting)
-    {
-       qDebug() << "calledLineRestrictionComplete" << success << setting;
-    }
-    void callingLineRestrictionComplete(bool success, QString setting)
-    {
-       qDebug() << "callingLineRestrictionComplete" << success << setting;
-    }
-    void hideCallerIdComplete(bool success, QString setting)
-    {
-       qDebug() << "hideCallerIdComplete" << success << setting;
-    }
-    void voiceCallWaitingComplete(bool success, QString setting)
+    void initTestCase()
     {
-       qDebug() << "voiceCallWaitingComplete" << success << setting;
-    }
+       m = new OfonoCallSettings(OfonoModem::ManualSelect, "/phonesim", this);
+       QCOMPARE(m->modem()->isValid(), true);  
 
-    void callingLinePresentationChanged(QString setting)
-    {
-       qDebug() << "callingLinePresentationChanged" << setting;
-    }
-    void calledLinePresentationChanged(QString setting)
-    {
-       qDebug() << "calledLinePresentationChanged" << setting;
-    }
-    void calledLineRestrictionChanged(QString setting)
-    {
-       qDebug() << "calledLineRestrictionChanged" << setting;
-    }
-    void callingLineRestrictionChanged(QString setting)
-    {
-       qDebug() << "callingLineRestrictionChanged" << setting;
-    }
-    void hideCallerIdChanged(QString setting)
-    {
-       qDebug() << "hideCallerIdChanged" << setting;
-    }
-    void voiceCallWaitingChanged(QString setting)
-    {
-       qDebug() << "voiceCallWaitingChanged" << setting;
+       if (!m->modem()->powered()) {
+           m->modem()->setPowered(true);
+            QTest::qWait(5000);
+        }
+        if (!m->modem()->online()) {
+           m->modem()->setOnline(true);
+            QTest::qWait(5000);
+        }
+       QCOMPARE(m->isValid(), true);
     }
 
-    void setHideCallerIdFailed()
-    {
-       qDebug() << "setHideCallerIdFailed";
-    }
-    void setVoiceCallWaitingFailed()
+    void testOfonoCallSettings()
     {
-       qDebug() << "setVoiceCallWaitingFailed";
-    }
+        QSignalSpy callingLinePresentationComplete(m, SIGNAL(callingLinePresentationComplete(bool, QString)));
+        QSignalSpy calledLinePresentationComplete(m, SIGNAL(calledLinePresentationComplete(bool, QString)));
+        QSignalSpy calledLineRestrictionComplete(m, SIGNAL(calledLineRestrictionComplete(bool, QString)));
+        QSignalSpy callingLineRestrictionComplete(m, SIGNAL(callingLineRestrictionComplete(bool, QString)));
+        QSignalSpy hideCallerIdComplete(m, SIGNAL(hideCallerIdComplete(bool, QString)));
+        QSignalSpy voiceCallWaitingComplete(m, SIGNAL(voiceCallWaitingComplete(bool, QString)));
 
-    void initTestCase()
-    {
-       m = new OfonoCallSettings(OfonoModem::AutomaticSelect, QString(), this);
-       connect(m, SIGNAL(validityChanged(bool)), this, 
-               SLOT(validityChanged(bool)));
-       connect(m, SIGNAL(callingLinePresentationChanged(QString)), this, 
-               SLOT(callingLinePresentationChanged(QString)));
-       connect(m, SIGNAL(calledLinePresentationChanged(QString)), this, 
-               SLOT(calledLinePresentationChanged(QString)));
-       connect(m, SIGNAL(calledLineRestrictionChanged(QString)), this, 
-               SLOT(calledLineRestrictionChanged(QString)));
-       connect(m, SIGNAL(callingLineRestrictionChanged(QString)), this, 
-               SLOT(callingLineRestrictionChanged(QString)));
-       connect(m, SIGNAL(hideCallerIdChanged(QString)), this, 
-               SLOT(hideCallerIdChanged(QString)));
-       connect(m, SIGNAL(voiceCallWaitingChanged(QString)), this, 
-               SLOT(voiceCallWaitingChanged(QString)));
-       connect(m, SIGNAL(setHideCallerIdFailed()), this, 
-               SLOT(setHideCallerIdFailed()));
-       connect(m, SIGNAL(setVoiceCallWaitingFailed()), this, 
-               SLOT(setVoiceCallWaitingFailed()));
-
-       connect(m, SIGNAL(callingLinePresentationComplete( bool, QString)), this, 
-               SLOT(callingLinePresentationComplete( bool, QString)));
-       connect(m, SIGNAL(calledLinePresentationComplete( bool, QString)), this, 
-               SLOT(calledLinePresentationComplete( bool, QString)));
-       connect(m, SIGNAL(calledLineRestrictionComplete( bool, QString)), this, 
-               SLOT(calledLineRestrictionComplete( bool, QString)));
-       connect(m, SIGNAL(callingLineRestrictionComplete( bool, QString)), this, 
-               SLOT(callingLineRestrictionComplete( bool, QString)));
-       connect(m, SIGNAL(hideCallerIdComplete( bool, QString)), this, 
-               SLOT(hideCallerIdComplete( bool, QString)));
-       connect(m, SIGNAL(voiceCallWaitingComplete( bool, QString)), this, 
-               SLOT(voiceCallWaitingComplete( bool, QString)));
+        QSignalSpy callingLinePresentationChanged(m, SIGNAL(callingLinePresentationChanged(QString)));        
+        QSignalSpy calledLinePresentationChanged(m, SIGNAL(calledLinePresentationChanged(QString)));        
+        QSignalSpy calledLineRestrictionChanged(m, SIGNAL(calledLineRestrictionChanged(QString)));        
+        QSignalSpy callingLineRestrictionChanged(m, SIGNAL(callingLineRestrictionChanged(QString)));        
+        QSignalSpy hideCallerIdChanged(m, SIGNAL(hideCallerIdChanged(QString)));        
+        QSignalSpy voiceCallWaitingChanged(m, SIGNAL(voiceCallWaitingChanged(QString)));        
 
-    }
+        QSignalSpy setHideCallerIdFailed(m, SIGNAL(setHideCallerIdFailed()));
+        QSignalSpy setVoiceCallWaitingFailed(m, SIGNAL(setVoiceCallWaitingFailed()));
 
-    void testOfonoCallSettings()
-    {
-       qDebug() << "validity:" << m->isValid();
        m->requestCallingLinePresentation();
-       QTest::qWait(1000);
+       QTest::qWait(5000);
+       QCOMPARE(callingLinePresentationComplete.count(), 1);
+       QVariantList list = callingLinePresentationComplete.takeFirst();
+       QCOMPARE(list.at(0).toBool(), true);
+       QCOMPARE(list.at(1).toString(), QString("enabled"));
+       QVERIFY(callingLinePresentationChanged.count() > 0);    
+       QCOMPARE(callingLinePresentationChanged.takeFirst().at(0).toString(), QString("enabled"));      
        m->requestCalledLinePresentation();
        QTest::qWait(1000);
+       QCOMPARE(calledLinePresentationComplete.count(), 1);
+       list = calledLinePresentationComplete.takeFirst();
+       QCOMPARE(list.at(0).toBool(), true);
+       QCOMPARE(list.at(1).toString(), QString("enabled"));
+       QVERIFY(calledLinePresentationChanged.count() > 0);     
+       QCOMPARE(calledLinePresentationChanged.takeFirst().at(0).toString(), QString("enabled"));       
        m->requestCalledLineRestriction();
        QTest::qWait(1000);
+       QCOMPARE(calledLineRestrictionComplete.count(), 1);
+       list = calledLineRestrictionComplete.takeFirst();
+       QCOMPARE(list.at(0).toBool(), true);
+       QCOMPARE(list.at(1).toString(), QString("enabled"));
+       QVERIFY(calledLineRestrictionChanged.count() > 0);      
+       QCOMPARE(calledLineRestrictionChanged.takeFirst().at(0).toString(), QString("enabled"));        
        m->requestCallingLineRestriction();
        QTest::qWait(1000);
+       QCOMPARE(callingLineRestrictionComplete.count(), 1);
+       list = callingLineRestrictionComplete.takeFirst();
+       QCOMPARE(list.at(0).toBool(), true);
+       QCOMPARE(list.at(1).toString(), QString("on"));
+       QVERIFY(callingLineRestrictionChanged.count() > 0);     
+       QCOMPARE(callingLineRestrictionChanged.takeFirst().at(0).toString(), QString("on"));    
        m->requestHideCallerId();
        QTest::qWait(1000);
+       QCOMPARE(hideCallerIdComplete.count(), 1);
+       list = hideCallerIdComplete.takeFirst();
+       QCOMPARE(list.at(0).toBool(), true);
+       QCOMPARE(list.at(1).toString(), QString("default"));
+       QVERIFY(hideCallerIdChanged.count() > 0);       
+       QCOMPARE(hideCallerIdChanged.takeFirst().at(0).toString(), QString("default"));
        m->requestVoiceCallWaiting();
        QTest::qWait(1000);
-       qDebug() << "setHideCallerId(enabled):";
+       QCOMPARE(voiceCallWaitingComplete.count(), 1);
+       list = voiceCallWaitingComplete.takeFirst();
+       QCOMPARE(list.at(0).toBool(), true);
+       QCOMPARE(list.at(1).toString(), QString("enabled"));
+       QVERIFY(voiceCallWaitingChanged.count() > 0);   
+       QCOMPARE(voiceCallWaitingChanged.takeFirst().at(0).toString(), QString("enabled"));
+       
+       m->setHideCallerId("abc");
+       QTest::qWait(1000);
+       QCOMPARE(setHideCallerIdFailed.count(), 1);
+       setHideCallerIdFailed.takeFirst();
+       m->setVoiceCallWaiting("abc");
+       QTest::qWait(1000);
+       QCOMPARE(setVoiceCallWaitingFailed.count(), 1);
+       setVoiceCallWaitingFailed.takeFirst();
+       
+       hideCallerIdChanged.clear();
        m->setHideCallerId("enabled");
-       qDebug() << "setVoiceCallWaiting(enabled):";
-       m->setVoiceCallWaiting("enabled");
-       qDebug() << "setHideCallerId(disabled):";
-       m->setHideCallerId("disabled");
-       qDebug() << "setVoiceCallWaiting(disabled):";
+       QTest::qWait(1000);
+       m->setHideCallerId("default");
+       QTest::qWait(1000);
+       QCOMPARE(hideCallerIdChanged.count(), 2);       
+       QCOMPARE(hideCallerIdChanged.takeFirst().at(0).toString(), QString("enabled"));
+       QCOMPARE(hideCallerIdChanged.takeFirst().at(0).toString(), QString("default"));
+       
+       voiceCallWaitingChanged.clear();        
        m->setVoiceCallWaiting("disabled");
-
-       QTest::qWait(120000);
+       QTest::qWait(5000);
+       m->setVoiceCallWaiting("enabled");
+       QTest::qWait(5000);
+       QCOMPARE(voiceCallWaitingChanged.count(), 2);   
+       QCOMPARE(voiceCallWaitingChanged.takeFirst().at(0).toString(), QString("disabled"));
+       QCOMPARE(voiceCallWaitingChanged.takeFirst().at(0).toString(), QString("enabled"));
     }