Mercurial Mercurial > oss > FCL > sf > mw > mmappfw / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
mmappfw_plat/qt_telephony_multimedia_service_api/tsrc/qtmscstest/qtmscstest.cpp
changeset 51 e61a04404bdf
parent 35 2ee890d2f7e7
equal deleted inserted replaced
44:d141fc1ad77b 51:e61a04404bdf 
     1 /*
 
     1 /*
 
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
 
     2  * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
 
     3 * All rights reserved.
 
     3  * All rights reserved.
 
     4 * This component and the accompanying materials are made available
 
     4  * This component and the accompanying materials are made available
 
     5 * under the terms of "Eclipse Public License v1.0"
 
     5  * under the terms of "Eclipse Public License v1.0"
 
     6 * which accompanies this distribution, and is available
 
     6  * which accompanies this distribution, and is available
 
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
     8 *
 
     8  *
 
     9 * Initial Contributors:
 
     9  * Initial Contributors:
 
    10 * Nokia Corporation - initial contribution.
 
    10  * Nokia Corporation - initial contribution.
 
    11 *
 
    11  *
 
    12 * Contributors:
 
    12  * Contributors:
 
    13 *
 
    13  *
 
    14 * Description: QTMS CS test
 
    14  * Description: QTMS CS test
 
    15 *
 
    15  *
 
    16 */
 
    16  */
 
    17 #include <QObject>
 
    17 #include <QObject>
 
    18 #include <QtTest/QtTest>
 
    18 #include <QtTest/QtTest>
 
    19 #include "qtestmains60.h"
 
    19 #include "qtestmains60.h"
 
    20 
    20 
    21 #include <qtms.h>
 
    21 #include <qtms.h>
 
    44 #include <qtmsringtone.h>
 
    44 #include <qtmsringtone.h>
 
    45 #include <qtmsinbandtone.h>
 
    45 #include <qtmsinbandtone.h>
 
    46 #include <tmsbuffer.h>
 
    46 #include <tmsbuffer.h>
 
    47 
    47 
    48 using namespace QTMS;
 
    48 using namespace QTMS;
 
    49 
       
    50 _LIT8(KRTBeepSequence, "\x00\x11\x0A\x0A\x08\x73\x0A\x40\x28\x0A\xF7\
 
    49 _LIT8(KRTBeepSequence, "\x00\x11\x0A\x0A\x08\x73\x0A\x40\x28\x0A\xF7\
 
    51 \x05\xFC\x40\x64\x0A\x08\x40\x32\x0A\xF7\x06\x0B");
 
    50 \x05\xFC\x40\x64\x0A\x08\x40\x32\x0A\xF7\x06\x0B");
 
    52 _LIT16(KTestFile1,   "c:\\data\\sounds\\digital\\test_8khz.wav");
 
    51 _LIT16(KTestFile1, "c:\\data\\sounds\\digital\\test_8khz.wav");
 
    53 
    52 
    54 class QTmsCsTest : public QObject
 
    53 class QTmsCsTest: public QObject
 
    55     {
 
    54 {
 
    56 Q_OBJECT
 
    55 Q_OBJECT
 
    57 private slots:
 
    56 private slots:
 
    58     void initTestCase();
 
    57     void initTestCase();
 
    59     void CSCallSetup();
 
    58     void CSCallSetup();
 
    60     
    59 
    61     void CreateUplink();
 
    60     void CreateUplink();
 
    62     void CreateDnlink();
 
    61     void CreateDnlink();
 
    63     void CreateMicSource();
 
    62     void CreateMicSource();
 
    64     void AddMicSourceToStream();
 
    63     void AddMicSourceToStream();
 
    65     void CreateModemSink();
 
    64     void CreateModemSink();
 
    66     void AddModemSinkToStream();
 
    65     void AddModemSinkToStream();
 
    67     void CreateModemSource();
 
    66     void CreateModemSource();
 
    68     void AddModemSourceToStream();
 
    67     void AddModemSourceToStream();
 
    69     void CreateSpeakerSink();
 
    68     void CreateSpeakerSink();
 
    70     void AddSpeakerSinkToStream();
 
    69     void AddSpeakerSinkToStream();
 
    71     
    70 
    72     void CreateStreamVol();
 
    71     void CreateStreamVol();
 
    73     void CreateStreamGain();
 
    72     void CreateStreamGain();
 
    74 
    73 
    75     void InitUplink();
 
    74     void InitUplink();
 
    76     void InitDnlink();
 
    75     void InitDnlink();
 
    77 
    76 
    78     void StartUplink();
 
    77     void StartUplink();
 
    79     void StopUplink();
 
    78     void StopUplink();
 
    80     void StartDnlink();
 
    79     void StartDnlink();
 
    81     
    80 
    82     void StreamVol();
 
    81     void StreamVol();
 
    83     void StreamGain();
 
    82     void StreamGain();
 
    84    // void StopDnlink();
 
    83     // void StopDnlink();
 
    85  
    84 
    86     void CreateGlobalVol();
 
    85     void CreateGlobalVol();
 
    87     void CreateGlobalGain();
 
    86     void CreateGlobalGain();
 
    88     void CreateRouting_data();
 
    87     void CreateRouting_data();
 
    89     void CreateRouting();
 
    88     void CreateRouting();
 
    90     
    89 
    91     void CreateInband_data();
 
    90     void CreateInband_data();
 
    92     void CreateInband();
 
    91     void CreateInband();
 
    93     void CreateDnlinkDtmf();
 
    92     void CreateDnlinkDtmf();
 
    94     void CreateUplinkDtmf();
 
    93     void CreateUplinkDtmf();
 
    95   
    94 
    96     void CreateRingTone();    
    95     void CreateRingTone();
 
    97 
    96 
    98     void InitRingTonePlayerFromProfiles();
 
    97     void InitRingTonePlayerFromProfiles();
 
    99     void PlayRingTone();
 
    98     void PlayRingTone();
 
   100     void PauseRingTone();
 
    99     void PauseRingTone();
 
   101     void MuteRingTone();
 
   100     void MuteRingTone();
 
   102     void StopRingTone();  
   101     void StopRingTone();
 
   103     void CloseRingTonePlayer();
 
   102     void CloseRingTonePlayer();
 
   104     
   103 
   105     void CloseUplink();
 
   104     void CloseUplink();
 
   106     void CloseDownlink();
 
   105     void CloseDownlink();
 
   107     void cleanupTestCase();
 
   106     void cleanupTestCase();
 
   108 public slots:
 
   107 public slots:
 
   109     //From TMSStreamObserver
 
   108     //From TMSStreamObserver
 
   110     void TMSStreamEvent(const QTMSStream& stream, QTMSSignalEvent event);
 
   109     void TMSStreamEvent(const QTMSStream& stream, QTMSSignalEvent event);
 
   111     //From TMSClientSinkObserver
 
   110     //From TMSClientSinkObserver
 
   112     void EffectsEvent(const QTMSEffect& tmseffect, QTMSSignalEvent event);
 
   111     void EffectsEvent(const QTMSEffect& tmseffect, QTMSSignalEvent event);
 
   113     //From TMSGlobalRoutingObserver
 
   112     //From TMSGlobalRoutingObserver
 
   114     void GlobalRoutingEvent(const QTMSGlobalRouting& routing,
 
   113     void GlobalRoutingEvent(const QTMSGlobalRouting& routing, QTMSSignalEvent event,
 
   115             QTMSSignalEvent event, QTMSAudioOutput output);
 
   114         QTMSAudioOutput output);
 
   116     //From TMSRingToneObserver
 
   115     //From TMSRingToneObserver
 
   117     void RingtoneEvent(const QTMSRingTone& rt, QTMSSignalEvent event);
 
   116     void RingtoneEvent(const QTMSRingTone& rt, QTMSSignalEvent event);
 
   118     //From TMSDTMFObserver
 
   117     //From TMSDTMFObserver
 
   119     void DTMFEvent(const QTMSDTMF& dtmf, QTMSSignalEvent event);
 
   118     void DTMFEvent(const QTMSDTMF& dtmf, QTMSSignalEvent event);
 
   120     //From TMSInbandToneObserver
 
   119     //From TMSInbandToneObserver
 
   121     void InbandToneEvent(const QTMSInbandTone& inbandtone,
 
   120     void InbandToneEvent(const QTMSInbandTone& inbandtone, QTMSSignalEvent event);
 
   122             QTMSSignalEvent event);
 
   121 
   123 
   122 private:
 
   124 private:    
       
   125     void InitRingToneSequencePlayer();
 
   123     void InitRingToneSequencePlayer();
 
   126     void InitRingTonePlayerFromFile();    
   124     void InitRingTonePlayerFromFile();
 
   127     void StopDnlink();
 
   125     void StopDnlink();
 
   128     void GetAvailableOutput();
 
   126     void GetAvailableOutput();
 
   129     void DisplayDevice(QTMSAudioOutput device);
 
   127     void DisplayDevice(QTMSAudioOutput device);
 
   130     
   128 
   131 private:    
   129 private:
 
   132     QTMSFactory *m_Factory;
 
   130     QTMSFactory *m_Factory;
 
   133     QTMSCall *m_Call;
 
   131     QTMSCall *m_Call;
 
   134     QTMSDTMF *m_Dnlnkdtmf;
 
   132     QTMSDTMF *m_Dnlnkdtmf;
 
   135     QTMSDTMF *m_Uplnkdtmf;
 
   133     QTMSDTMF *m_Uplnkdtmf;
 
   136     QTMSStream *m_Dnlink;
 
   134     QTMSStream *m_Dnlink;
 
   145     QTMSEffect *m_GlobalGain;
 
   143     QTMSEffect *m_GlobalGain;
 
   146     QTMSGlobalRouting *m_Routing;
 
   144     QTMSGlobalRouting *m_Routing;
 
   147     QTMSInbandTone *m_InbandTonePlayer;
 
   145     QTMSInbandTone *m_InbandTonePlayer;
 
   148     QTMSRingTone *m_RingTonePlayer;
 
   146     QTMSRingTone *m_RingTonePlayer;
 
   149     GString* m_RTStr;
 
   147     GString* m_RTStr;
 
   150     GString* m_TTSStr;   
   148     GString* m_TTSStr;
 
   151     QSignalSpy *m_UplinkSpy;
 
   149     QSignalSpy *m_UplinkSpy;
 
   152     QSignalSpy *m_DnlinkSpy;
 
   150     QSignalSpy *m_DnlinkSpy;
 
   153     QSignalSpy *m_InbandSpy;
 
   151     QSignalSpy *m_InbandSpy;
 
   154     QSignalSpy *m_RoutingSpy; 
   152     QSignalSpy *m_RoutingSpy;
 
   155     OutputVector  m_Availableoutputs;
 
   153     OutputVector m_Availableoutputs;
 
   156 
   154 
   157     };
 
   155 };
 
   158 
   156 
   159 void QTmsCsTest::initTestCase()
 
   157 void QTmsCsTest::initTestCase()
 
   160     {
 
   158 {
 
   161     qDebug("Start QTms CS tests");
 
   159     qDebug("Start QTms CS tests");
 
   162     
   160 
   163     g_setenv("G_SLICE", "always-malloc", 1);
 
   161     g_setenv("G_SLICE", "always-malloc", 1);
 
   164     m_Factory = NULL;
 
   162     m_Factory = NULL;
 
   165     m_Call = NULL;
 
   163     m_Call = NULL;
 
   166     m_Dnlink = NULL;
 
   164     m_Dnlink = NULL;
 
   167     m_Uplink = NULL;  
   165     m_Uplink = NULL;
 
   168     m_MicSource = NULL;
 
   166     m_MicSource = NULL;
 
   169     m_ModemSource = NULL;
 
   167     m_ModemSource = NULL;
 
   170     m_SpeakerSink = NULL;
 
   168     m_SpeakerSink = NULL;
 
   171     m_ModemSink = NULL;
 
   169     m_ModemSink = NULL;
 
   172     m_Vol = NULL;
 
   170     m_Vol = NULL;
 
   173     m_Gain = NULL;
 
   171     m_Gain = NULL;
 
   174     m_GlobalVol = NULL;
 
   172     m_GlobalVol = NULL;
 
   175     m_GlobalGain = NULL;
 
   173     m_GlobalGain = NULL;
 
   176     m_Routing = NULL;  
   174     m_Routing = NULL;
 
   177     m_Dnlnkdtmf = NULL;
 
   175     m_Dnlnkdtmf = NULL;
 
   178     m_Uplnkdtmf = NULL;
 
   176     m_Uplnkdtmf = NULL;
 
   179     m_InbandTonePlayer = NULL;
 
   177     m_InbandTonePlayer = NULL;
 
   180     m_RingTonePlayer = NULL;
 
   178     m_RingTonePlayer = NULL;
 
   181     m_UplinkSpy = NULL;
 
   179     m_UplinkSpy = NULL;
 
   182     m_DnlinkSpy = NULL;
 
   180     m_DnlinkSpy = NULL;
 
   183     
   181 
   184     QTMSVer *ver(NULL);
 
   182     QTMSVer *ver(NULL);
 
   185     gint status;
 
   183     gint status;
 
   186     status = QTMSFactory::CreateFactory(m_Factory, *ver);
 
   184     status = QTMSFactory::CreateFactory(m_Factory, *ver);
 
   187     
   185 
   188     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   186     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   189     
   187 
   190     qRegisterMetaType<QTMSSignalEvent>("QTMSSignalEvent");
 
   188     qRegisterMetaType<QTMSSignalEvent> ("QTMSSignalEvent");
 
   191     qRegisterMetaType<QTMSAudioOutput>("QTMSAudioOutput");
 
   189     qRegisterMetaType<QTMSAudioOutput> ("QTMSAudioOutput");
 
   192 
   190 
   193  
   191 }
 
   194     }
 
       
   195 
   192 
   196 void QTmsCsTest::cleanupTestCase()
 
   193 void QTmsCsTest::cleanupTestCase()
 
   197     {
 
   194 {
 
   198     qDebug("End QTms tests");
 
   195     qDebug("End QTms tests");
 
   199     
   196 
   200     StopDnlink();
 
   197     StopDnlink();
 
   201      
   198 
   202     m_Factory->DeleteSource(m_MicSource);   
   199     m_Factory->DeleteSource(m_MicSource);
 
   203     m_Factory->DeleteSource(m_ModemSource);  
   200     m_Factory->DeleteSource(m_ModemSource);
 
   204     m_Factory->DeleteSink(m_ModemSink);
 
   201     m_Factory->DeleteSink(m_ModemSink);
 
   205     m_Factory->DeleteSink(m_SpeakerSink);
 
   202     m_Factory->DeleteSink(m_SpeakerSink);
 
   206              
   203 
   207     m_Factory->DeleteDTMF(m_Dnlnkdtmf);
 
   204     m_Factory->DeleteDTMF(m_Dnlnkdtmf);
 
   208     m_Factory->DeleteInbandTonePlayer(m_InbandTonePlayer);
 
   205     m_Factory->DeleteInbandTonePlayer(m_InbandTonePlayer);
 
   209     m_Factory->DeleteRingTonePlayer(m_RingTonePlayer);
 
   206     m_Factory->DeleteRingTonePlayer(m_RingTonePlayer);
 
   210     
   207 
   211     m_Factory->DeleteEffect(m_Vol);
 
   208     m_Factory->DeleteEffect(m_Vol);
 
   212     m_Factory->DeleteEffect(m_Gain);
 
   209     m_Factory->DeleteEffect(m_Gain);
 
   213     m_Factory->DeleteEffect(m_GlobalVol);
 
   210     m_Factory->DeleteEffect(m_GlobalVol);
 
   214     m_Factory->DeleteEffect(m_GlobalGain);
 
   211     m_Factory->DeleteEffect(m_GlobalGain);
 
   215     
   212 
   216     m_Factory->DeleteGlobalRouting(m_Routing);
 
   213     m_Factory->DeleteGlobalRouting(m_Routing);
 
   217     
   214 
   218     m_Call->DeleteStream(m_Uplink);
 
   215     m_Call->DeleteStream(m_Uplink);
 
   219     m_Call->DeleteStream(m_Dnlink);
 
   216     m_Call->DeleteStream(m_Dnlink);
 
   220         
   217 
   221     m_Factory->DeleteCall(m_Call);
 
   218     m_Factory->DeleteCall(m_Call);
 
   222 
   219 
   223     delete m_Factory;
 
   220     delete m_Factory;
 
   224       
   221 
   225     }
 
   222 }
 
   226 
   223 
   227 void QTmsCsTest::CSCallSetup()
 
   224 void QTmsCsTest::CSCallSetup()
 
   228     {
 
   225 {
 
   229     gint status(QTMS_RESULT_SUCCESS);
 
   226     gint status(QTMS_RESULT_SUCCESS);
 
   230     if (m_Factory && !m_Call)
 
   227     if (m_Factory && !m_Call) {
 
   231         {
 
       
   232         gboolean issupported(FALSE);
 
   228         gboolean issupported(FALSE);
 
   233         m_Factory->IsCallTypeSupported(QTMS_CALL_CS, issupported);
 
   229         m_Factory->IsCallTypeSupported(QTMS_CALL_CS, issupported);
 
   234         QVERIFY(issupported == TRUE);
 
   230         QVERIFY(issupported == TRUE);
 
   235         status = m_Factory->CreateCall(QTMS_CALL_CS, m_Call, 0);
 
   231         status = m_Factory->CreateCall(QTMS_CALL_CS, m_Call, 0);
 
   236         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   232         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   237         QTMSCallType calltype = m_Call->GetCallType();
 
   233         QTMSCallType calltype = m_Call->GetCallType();
 
   238         QVERIFY(calltype == QTMS_CALL_CS);
 
   234         QVERIFY(calltype == QTMS_CALL_CS);
 
   239         }
 
   235     }
 
   240     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   236     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   241     }
 
   237 }
 
   242 
   238 
   243 void QTmsCsTest::CreateUplink()
 
   239 void QTmsCsTest::CreateUplink()
 
   244     {
 
   240 {
 
   245     gint status(QTMS_RESULT_SUCCESS);
 
   241     gint status(QTMS_RESULT_SUCCESS);
 
   246 
   242 
   247     if (m_Call)
 
   243     if (m_Call) {
 
   248         {
 
       
   249         status = m_Call->CreateStream(QTMS_STREAM_UPLINK, m_Uplink);
 
   244         status = m_Call->CreateStream(QTMS_STREAM_UPLINK, m_Uplink);
 
   250         
   245 
   251         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   246         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   252 
   247 
   253         m_UplinkSpy = new QSignalSpy(m_Uplink,
 
   248         m_UplinkSpy = new QSignalSpy(m_Uplink,
 
   254                 SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));
 
   249             SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));
 
   255 
   250 
   256         QVERIFY( m_UplinkSpy->isValid() );
 
   251         QVERIFY( m_UplinkSpy->isValid() );
 
   257 
   252 
   258         //QCOMPARE(m_UplinkSpy->count(), 0 );
 
   253         //QCOMPARE(m_UplinkSpy->count(), 0 );
 
   259 
   254 
   260         
   255 
   261         connect(m_Uplink,
 
   256         connect(m_Uplink, SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)), this,
 
   262                 SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)),
 
   257             SLOT(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));
 
   263                 this,
 
   258 
   264                 SLOT(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));
 
   259     }
 
   265 
   260 }
 
   266         }
 
   261 
   267     }
 
   262 void QTmsCsTest::CreateDnlink()
 
   268 
   263 {
 
   269  void QTmsCsTest::CreateDnlink()
 
   264     gint status(QTMS_RESULT_SUCCESS);
 
   270     {
 
   265 
   271     gint status(QTMS_RESULT_SUCCESS);
 
   266     if (m_Call) {
 
   272 
       
   273     if (m_Call)
 
       
   274         {
 
       
   275         status = m_Call->CreateStream(QTMS_STREAM_DOWNLINK, m_Dnlink);
 
   267         status = m_Call->CreateStream(QTMS_STREAM_DOWNLINK, m_Dnlink);
 
   276 
   268 
   277         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   269         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   278         
   270 
   279         m_DnlinkSpy = new QSignalSpy(m_Dnlink,
 
   271         m_DnlinkSpy = new QSignalSpy(m_Dnlink,
 
   280                 SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));
 
   272             SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));
 
   281 
   273 
   282         QVERIFY( m_DnlinkSpy->isValid() );
 
   274         QVERIFY( m_DnlinkSpy->isValid() );
 
   283 
   275 
   284         //QCOMPARE(m_DnlinkSpy->count(), 0 );
 
   276         //QCOMPARE(m_DnlinkSpy->count(), 0 );
 
   285         
   277 
   286         connect(m_Dnlink,
 
   278         connect(m_Dnlink, SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)), this,
 
   287                 SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)),
 
   279             SLOT(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));
 
   288                 this,
 
   280     }
 
   289                 SLOT(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));             
   281 }
 
   290         }
 
   282 
   291     }
 
   283 void QTmsCsTest::CreateModemSink()
 
   292  
   284 {
 
   293  
   285     gint status(QTMS_RESULT_SUCCESS);
 
   294  void QTmsCsTest::CreateModemSink()
 
   286 
   295      {
 
   287     if (m_Factory && !m_ModemSink) {
 
   296      gint status(QTMS_RESULT_SUCCESS);
 
   288         status = m_Factory->CreateSink(QTMS_SINK_MODEM, m_ModemSink);
 
   297 
   289     }
 
   298      if (m_Factory && !m_ModemSink)
 
   290     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   299          {
 
   291 }
 
   300          status = m_Factory->CreateSink(QTMS_SINK_MODEM, m_ModemSink);
 
   292 
   301          }
 
   293 void QTmsCsTest::CreateModemSource()
 
   302      QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   294 {
 
   303      }
 
   295     gint status(QTMS_RESULT_SUCCESS);
 
   304  
   296 
   305  void QTmsCsTest::CreateModemSource()
 
   297     if (m_Factory && !m_ModemSource) {
 
   306      {
 
   298         status = m_Factory->CreateSource(QTMS_SOURCE_MODEM, m_ModemSource);
 
   307      gint status(QTMS_RESULT_SUCCESS);
 
   299     }
 
   308 
   300     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   309      if (m_Factory && !m_ModemSource)
 
   301 }
 
   310          {
 
   302 
   311          status = m_Factory->CreateSource(QTMS_SOURCE_MODEM, m_ModemSource);
 
   303 void QTmsCsTest::AddModemSinkToStream()
 
   312          }
 
   304 {
 
   313      QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   305     gint status(QTMS_RESULT_SUCCESS);
 
   314      }
 
   306     if (m_Uplink && m_ModemSink) {
 
   315 
   307         status = m_Uplink->AddSink(m_ModemSink);
 
   316  void QTmsCsTest::AddModemSinkToStream()
 
   308     }
 
   317      {
 
   309     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   318      gint status(QTMS_RESULT_SUCCESS);
 
   310 }
 
   319      if (m_Uplink && m_ModemSink)
 
   311 
   320          {
 
   312 void QTmsCsTest::AddModemSourceToStream()
 
   321          status = m_Uplink->AddSink(m_ModemSink);
 
   313 {
 
   322          }
 
   314     gint status(QTMS_RESULT_SUCCESS);
 
   323      QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   315     if (m_Dnlink && m_ModemSource) {
 
   324      }
 
   316         status = m_Dnlink->AddSource(m_ModemSource);
 
   325  
   317     }
 
   326  void QTmsCsTest::AddModemSourceToStream()
 
   318     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   327      {
 
   319 }
 
   328      gint status(QTMS_RESULT_SUCCESS);
 
   320 
   329      if (m_Dnlink && m_ModemSource)
 
   321 void QTmsCsTest::CreateMicSource()
 
   330          {
 
   322 {
 
   331          status = m_Dnlink->AddSource(m_ModemSource);
 
   323     gint status(QTMS_RESULT_SUCCESS);
 
   332          }
 
   324 
   333      QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   325     if (m_Factory && !m_MicSource) {
 
   334      }
 
   326         status = m_Factory->CreateSource(TMS_SOURCE_MIC, m_MicSource);
 
   335 
   327     }
 
   336 
   328     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   337  void QTmsCsTest::CreateMicSource()
 
   329 }
 
   338      {
 
   330 
   339      gint status(QTMS_RESULT_SUCCESS);
 
   331 void QTmsCsTest::AddMicSourceToStream()
 
   340 
   332 {
 
   341      if (m_Factory && !m_MicSource)
 
   333     gint status(QTMS_RESULT_SUCCESS);
 
   342          {
 
   334     if (m_Uplink && m_MicSource) {
 
   343          status = m_Factory->CreateSource(TMS_SOURCE_MIC, m_MicSource);
 
   335         status = m_Uplink->AddSource(m_MicSource);
 
   344          }
 
   336     }
 
   345      QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   337     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   346      }
 
   338 }
 
   347 
   339 
   348  void QTmsCsTest::AddMicSourceToStream()
 
   340 void QTmsCsTest::CreateSpeakerSink()
 
   349      {
 
   341 {
 
   350      gint status(QTMS_RESULT_SUCCESS);
 
   342     gint status(QTMS_RESULT_SUCCESS);
 
   351      if (m_Uplink && m_MicSource)
 
   343 
   352          {
 
   344     if (m_Factory && !m_SpeakerSink) {
 
   353          status = m_Uplink->AddSource(m_MicSource);
 
   345         status = m_Factory->CreateSink(QTMS_SINK_SPEAKER, m_SpeakerSink);
 
   354          }
 
   346     }
 
   355      QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   347     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   356      }
 
   348 }
 
   357 
   349 
   358  void QTmsCsTest::CreateSpeakerSink()
 
   350 void QTmsCsTest::AddSpeakerSinkToStream()
 
   359      {
 
   351 {
 
   360      gint status(QTMS_RESULT_SUCCESS);
 
   352     gint status(QTMS_RESULT_SUCCESS);
 
   361 
   353     if (m_Dnlink && m_SpeakerSink) {
 
   362      if (m_Factory && !m_SpeakerSink)
 
   354         status = m_Dnlink->AddSink(m_SpeakerSink);
 
   363          {
 
   355         qDebug("QTMS speaker sink added to stream");
 
   364          status = m_Factory->CreateSink(QTMS_SINK_SPEAKER, m_SpeakerSink);
 
   356     }
 
   365          }
 
   357     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   366      QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   358 }
 
   367      }
 
   359 
   368 
   360 void QTmsCsTest::InitUplink()
 
   369  void QTmsCsTest::AddSpeakerSinkToStream()
 
   361 {
 
   370      {
 
   362     QVERIFY(m_Uplink->Init() == QTMS_RESULT_SUCCESS);
 
   371      gint status(QTMS_RESULT_SUCCESS);
 
   363     QTest::qWait(1000);
 
   372      if (m_Dnlink && m_SpeakerSink)
 
   364     //QCOMPARE(m_UplinkSpy->count(), 1 );
 
   373          {
 
   365 }
 
   374          status = m_Dnlink->AddSink(m_SpeakerSink);
 
   366 
   375          qDebug("QTMS speaker sink added to stream");
 
   367 void QTmsCsTest::InitDnlink()
 
   376          }
 
   368 {
 
   377      QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   369     QVERIFY(m_Dnlink->Init() == QTMS_RESULT_SUCCESS);
 
   378      }
 
   370     QTest::qWait(1000);
 
   379  
   371     //QCOMPARE(m_DnlinkSpy->count(), 1 );
 
   380  void QTmsCsTest::InitUplink()
 
   372 }
 
   381      {    
   373 
   382      QVERIFY(m_Uplink->Init() == QTMS_RESULT_SUCCESS);
 
   374 void QTmsCsTest::StartUplink()
 
   383      QTest::qWait(1000);  
   375 {
 
   384      //QCOMPARE(m_UplinkSpy->count(), 1 );
 
   376     QVERIFY(m_Uplink->Start() == QTMS_RESULT_SUCCESS);
 
   385      }
 
   377     QTest::qWait(1000);
 
   386 
   378     //QCOMPARE(m_UplinkSpy->count(), 2 );
 
   387  void QTmsCsTest::InitDnlink()
 
   379 }
 
   388      {
 
   380 
   389      QVERIFY(m_Dnlink->Init() == QTMS_RESULT_SUCCESS);
 
   381 void QTmsCsTest::StartDnlink()
 
   390      QTest::qWait(1000);      
   382 {
 
   391      //QCOMPARE(m_DnlinkSpy->count(), 1 );
 
       
   392      }
 
       
   393 
       
   394  void QTmsCsTest::StartUplink()
 
       
   395      {
 
       
   396      QVERIFY(m_Uplink->Start() == QTMS_RESULT_SUCCESS);
 
       
   397      QTest::qWait(1000);  
       
   398      //QCOMPARE(m_UplinkSpy->count(), 2 );
 
       
   399      }
 
       
   400 
       
   401  void QTmsCsTest::StartDnlink()
 
       
   402     {
 
       
   403     QVERIFY(m_Dnlink->Start() == QTMS_RESULT_SUCCESS);
 
   383     QVERIFY(m_Dnlink->Start() == QTMS_RESULT_SUCCESS);
 
   404     QTest::qWait(1000);      
   384     QTest::qWait(1000);
 
   405     //QCOMPARE(m_DnlinkSpy->count(), 2 );
 
   385     //QCOMPARE(m_DnlinkSpy->count(), 2 );
 
   406     }
 
   386 }
 
   407 void QTmsCsTest::StopUplink()
 
   387 void QTmsCsTest::StopUplink()
 
   408     {
 
   388 {
 
   409     QVERIFY(m_Uplink->Stop() == QTMS_RESULT_SUCCESS);
 
   389     QVERIFY(m_Uplink->Stop() == QTMS_RESULT_SUCCESS);
 
   410     QTest::qWait(1000);
 
   390     QTest::qWait(1000);
 
   411     //QCOMPARE(m_UplinkSpy->count(), 3 );
 
   391     //QCOMPARE(m_UplinkSpy->count(), 3 );
 
   412     }
 
   392 }
 
   413 
   393 
   414 void QTmsCsTest::StopDnlink()
 
   394 void QTmsCsTest::StopDnlink()
 
   415     {
 
   395 {
 
   416     QVERIFY(m_Dnlink->Stop() == QTMS_RESULT_SUCCESS);
 
   396     QVERIFY(m_Dnlink->Stop() == QTMS_RESULT_SUCCESS);
 
   417     QTest::qWait(1000);  
   397     QTest::qWait(1000);
 
   418     //QCOMPARE(m_DnlinkSpy->count(), 3 );
 
   398     //QCOMPARE(m_DnlinkSpy->count(), 3 );
 
   419     }
 
   399 }
 
   420 
   400 
   421 void QTmsCsTest::CloseUplink()
 
   401 void QTmsCsTest::CloseUplink()
 
   422     {
 
   402 {
 
   423     m_Uplink->Deinit();
 
   403     m_Uplink->Deinit();
 
   424     QTest::qWait(1000);
 
   404     QTest::qWait(1000);
 
   425     if (m_Uplink)
 
   405     if (m_Uplink) {
 
   426         {
 
   406         if (m_Gain) {
 
   427         if (m_Gain)
 
       
   428             {
 
       
   429             QVERIFY(m_Uplink->RemoveEffect(m_Gain)== QTMS_RESULT_SUCCESS);
 
   407             QVERIFY(m_Uplink->RemoveEffect(m_Gain)== QTMS_RESULT_SUCCESS);
 
   430             }
 
   408         }
 
   431         if (m_MicSource)
 
   409         if (m_MicSource) {
 
   432             {
 
       
   433             QVERIFY(m_Uplink->RemoveSource(m_MicSource)== QTMS_RESULT_SUCCESS);
 
   410             QVERIFY(m_Uplink->RemoveSource(m_MicSource)== QTMS_RESULT_SUCCESS);
 
   434             }
 
   411         }
 
   435         if (m_ModemSink)
 
   412         if (m_ModemSink) {
 
   436             {
 
       
   437             QVERIFY(m_Uplink->RemoveSink(m_ModemSink)== QTMS_RESULT_SUCCESS);
 
   413             QVERIFY(m_Uplink->RemoveSink(m_ModemSink)== QTMS_RESULT_SUCCESS);
 
   438             }
 
   414         }
 
   439         }
 
   415     }
 
   440     }
 
   416 }
 
   441 
   417 
   442 void QTmsCsTest::CloseDownlink()
 
   418 void QTmsCsTest::CloseDownlink()
 
   443     {  
   419 {
 
   444     m_Dnlink->Deinit();
 
   420     m_Dnlink->Deinit();
 
   445     QTest::qWait(1000);
 
   421     QTest::qWait(1000);
 
   446     if (m_Dnlink)
 
   422     if (m_Dnlink) {
 
   447         {
 
   423         if (m_Vol) {
 
   448         if (m_Vol)
 
       
   449             {
 
       
   450             QVERIFY(m_Dnlink->RemoveEffect(m_Vol)== QTMS_RESULT_SUCCESS);
 
   424             QVERIFY(m_Dnlink->RemoveEffect(m_Vol)== QTMS_RESULT_SUCCESS);
 
   451             }
 
   425         }
 
   452         if (m_ModemSource)
 
   426         if (m_ModemSource) {
 
   453             {
 
       
   454             QVERIFY(m_Dnlink->RemoveSource(m_ModemSource)== QTMS_RESULT_SUCCESS);
 
   427             QVERIFY(m_Dnlink->RemoveSource(m_ModemSource)== QTMS_RESULT_SUCCESS);
 
   455             }
 
   428         }
 
   456         if (m_SpeakerSink)
 
   429         if (m_SpeakerSink) {
 
   457             {
 
       
   458             QVERIFY(m_Dnlink->RemoveSink(m_SpeakerSink) == QTMS_RESULT_SUCCESS);
 
   430             QVERIFY(m_Dnlink->RemoveSink(m_SpeakerSink) == QTMS_RESULT_SUCCESS);
 
   459             }
 
   431         }
 
   460         }
 
   432     }
 
   461 
   433 
   462     }
 
   434 }
 
   463 
   435 
   464 void QTmsCsTest::CreateStreamVol()
 
   436 void QTmsCsTest::CreateStreamVol()
 
   465     {
 
   437 {
 
   466     gint status(QTMS_RESULT_SUCCESS);
 
   438     gint status(QTMS_RESULT_SUCCESS);
 
   467 
   439 
   468     if (m_Factory && !m_Vol)
 
   440     if (m_Factory && !m_Vol) {
 
   469         {
 
       
   470         status = m_Factory->CreateEffect(QTMS_EFFECT_VOLUME, m_Vol);
 
   441         status = m_Factory->CreateEffect(QTMS_EFFECT_VOLUME, m_Vol);
 
   471 
   442 
   472         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   443         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   473 
   444 
   474         connect(static_cast<QTMSVolumeEffect*> (m_Vol),
 
   445         connect(static_cast<QTMSVolumeEffect*> (m_Vol),
 
   475                 SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)),
 
   446             SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)), this,
 
   476                 this, SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));
 
   447             SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));
 
   477         
   448 
   478         if(m_Dnlink)
 
   449         if (m_Dnlink) {
 
   479             {
 
   450             status = m_Dnlink->AddEffect(m_Vol);
 
   480             status = m_Dnlink->AddEffect(m_Vol);          
   451         }
 
   481             }
 
   452         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   482         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   453 
   483 
   454     }
 
   484         }
 
   455 }
 
   485     }
 
       
   486 
   456 
   487 void QTmsCsTest::StreamVol()
 
   457 void QTmsCsTest::StreamVol()
 
   488     {
 
   458 {
 
   489     gint status(QTMS_RESULT_SUCCESS);
 
   459     gint status(QTMS_RESULT_SUCCESS);
 
   490     guint maxvol(0);
 
   460     guint maxvol(0);
 
   491     if (m_Vol)
 
   461     if (m_Vol) {
 
   492         {
 
       
   493         status = static_cast<QTMSVolumeEffect*> (m_Vol)->GetMaxLevel(maxvol);
 
   462         status = static_cast<QTMSVolumeEffect*> (m_Vol)->GetMaxLevel(maxvol);
 
   494         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   463         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   495 
   464 
   496         status = static_cast<QTMSVolumeEffect*> (m_Vol)->SetLevel(maxvol);
 
   465         status = static_cast<QTMSVolumeEffect*> (m_Vol)->SetLevel(maxvol);
 
   497         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   466         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   500         guint vol(0);
 
   469         guint vol(0);
 
   501         status = static_cast<QTMSVolumeEffect*> (m_Vol)->GetLevel(vol);
 
   470         status = static_cast<QTMSVolumeEffect*> (m_Vol)->GetLevel(vol);
 
   502         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   471         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   503 
   472 
   504         QCOMPARE(vol,maxvol);
 
   473         QCOMPARE(vol,maxvol);
 
   505         }
 
   474     }
 
   506     }
 
   475 }
 
   507 
   476 
   508 void QTmsCsTest::CreateStreamGain()
 
   477 void QTmsCsTest::CreateStreamGain()
 
   509     {
 
   478 {
 
   510     gint status(QTMS_RESULT_SUCCESS);
 
   479     gint status(QTMS_RESULT_SUCCESS);
 
   511 
   480 
   512     if (m_Factory && !m_Gain)
 
   481     if (m_Factory && !m_Gain) {
 
   513         {
 
       
   514         status = m_Factory->CreateEffect(QTMS_EFFECT_GAIN, m_Gain);
 
   482         status = m_Factory->CreateEffect(QTMS_EFFECT_GAIN, m_Gain);
 
   515         
   483 
   516         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   484         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   517 
   485 
   518         connect(static_cast<QTMSGainEffect*> (m_Gain),
 
   486         connect(static_cast<QTMSGainEffect*> (m_Gain),
 
   519                 SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)),
 
   487             SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)), this,
 
   520                 this,
 
   488             SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));
 
   521                 SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));
 
   489 
   522         
   490         if (m_Uplink) {
 
   523         if(m_Uplink)
 
       
   524             {
 
       
   525             status = m_Uplink->AddEffect(m_Gain);
 
   491             status = m_Uplink->AddEffect(m_Gain);
 
   526             }
 
   492         }
 
   527         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   493         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   528         }
 
   494     }
 
   529     }
 
   495 }
 
   530 
   496 
   531 void QTmsCsTest::StreamGain()
 
   497 void QTmsCsTest::StreamGain()
 
   532     {
 
   498 {
 
   533     gint status(QTMS_RESULT_SUCCESS);
 
   499     gint status(QTMS_RESULT_SUCCESS);
 
   534     if (m_Gain)
 
   500     if (m_Gain) {
 
   535         {
 
       
   536         guint maxgain(0);
 
   501         guint maxgain(0);
 
   537         static_cast<QTMSGainEffect*> (m_Gain)->GetMaxLevel(maxgain);
 
   502         static_cast<QTMSGainEffect*> (m_Gain)->GetMaxLevel(maxgain);
 
   538         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   503         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   539 
   504 
   540         static_cast<QTMSGainEffect*> (m_Gain)->SetLevel(maxgain);
 
   505         static_cast<QTMSGainEffect*> (m_Gain)->SetLevel(maxgain);
 
   544         guint gain(0);
 
   509         guint gain(0);
 
   545         static_cast<QTMSGainEffect*> (m_Gain)->GetLevel(gain);
 
   510         static_cast<QTMSGainEffect*> (m_Gain)->GetLevel(gain);
 
   546         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   511         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   547 
   512 
   548         QCOMPARE(gain,maxgain);
 
   513         QCOMPARE(gain,maxgain);
 
   549         }
 
   514     }
 
   550 
   515 
   551     }
 
   516 }
 
   552 
       
   553 
   517 
   554 void QTmsCsTest::CreateGlobalVol()
 
   518 void QTmsCsTest::CreateGlobalVol()
 
   555     {
 
   519 {
 
   556     gint status(QTMS_RESULT_SUCCESS);
 
   520     gint status(QTMS_RESULT_SUCCESS);
 
   557 
   521 
   558     if (m_Factory && !m_GlobalVol)
 
   522     if (m_Factory && !m_GlobalVol) {
 
   559         {
 
       
   560         status = m_Factory->CreateEffect(QTMS_EFFECT_GLOBAL_VOL, m_GlobalVol);
 
   523         status = m_Factory->CreateEffect(QTMS_EFFECT_GLOBAL_VOL, m_GlobalVol);
 
   561 
   524 
   562         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   525         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   563 
   526 
   564         connect(static_cast<QTMSGlobalVolEffect*> (m_GlobalVol),
 
   527         connect(static_cast<QTMSGlobalVolEffect*> (m_GlobalVol),
 
   565                 SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)),
 
   528             SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)), this,
 
   566                 this, SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));
 
   529             SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));
 
   567 
   530 
   568         guint maxvol(0);
 
   531         guint maxvol(0);
 
   569         status = static_cast<QTMSGlobalVolEffect*>(m_GlobalVol)->GetMaxLevel(
 
   532         status = static_cast<QTMSGlobalVolEffect*> (m_GlobalVol)->GetMaxLevel(maxvol);
 
   570                 maxvol);
 
   533         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   571         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   534 
   572 
   535         status = static_cast<QTMSGlobalVolEffect*> (m_GlobalVol)->SetLevel(maxvol);
 
   573         status = static_cast<QTMSGlobalVolEffect*>(m_GlobalVol)->SetLevel(
 
       
   574                 maxvol);
 
       
   575         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   536         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   576         QTest::qWait(1000);
 
   537         QTest::qWait(1000);
 
   577 
   538 
   578         guint vol(0);
 
   539         guint vol(0);
 
   579         status = static_cast<QTMSGlobalVolEffect*> (m_GlobalVol)->GetLevel(vol);
 
   540         status = static_cast<QTMSGlobalVolEffect*> (m_GlobalVol)->GetLevel(vol);
 
   580         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   541         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   581 
   542 
   582         QCOMPARE(vol,maxvol);
 
   543         QCOMPARE(vol,maxvol);
 
   583 
   544 
   584         }
 
   545     }
 
   585     }
 
   546 }
 
   586 
       
   587 
   547 
   588 void QTmsCsTest::CreateGlobalGain()
 
   548 void QTmsCsTest::CreateGlobalGain()
 
   589     {
 
   549 {
 
   590     gint status(QTMS_RESULT_SUCCESS);
 
   550     gint status(QTMS_RESULT_SUCCESS);
 
   591 
   551 
   592     if (m_Factory && !m_GlobalGain)
 
   552     if (m_Factory && !m_GlobalGain) {
 
   593         {
 
       
   594         status = m_Factory->CreateEffect(QTMS_EFFECT_GLOBAL_GAIN, m_GlobalGain);
 
   553         status = m_Factory->CreateEffect(QTMS_EFFECT_GLOBAL_GAIN, m_GlobalGain);
 
   595         
   554 
   596         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   555         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   597 
   556 
   598         connect(static_cast<QTMSGlobalGainEffect*> (m_GlobalGain),
 
   557         connect(static_cast<QTMSGlobalGainEffect*> (m_GlobalGain),
 
   599                 SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)),
 
   558             SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)), this,
 
   600                 this,
 
   559             SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));
 
   601                 SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));
 
   560 
   602         
       
   603         guint maxgain(0);
 
   561         guint maxgain(0);
 
   604         static_cast<QTMSGlobalGainEffect*>(m_GlobalGain)->GetMaxLevel(maxgain);
 
   562         static_cast<QTMSGlobalGainEffect*> (m_GlobalGain)->GetMaxLevel(maxgain);
 
   605         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   563         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   606         
   564 
   607         static_cast<QTMSGlobalGainEffect*>(m_GlobalGain)->SetLevel(maxgain);
 
   565         static_cast<QTMSGlobalGainEffect*> (m_GlobalGain)->SetLevel(maxgain);
 
   608         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   566         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   609         QTest::qWait(1000);
 
   567         QTest::qWait(1000);
 
   610         
   568 
   611         guint gain(0);
 
   569         guint gain(0);
 
   612         static_cast<QTMSGlobalGainEffect*>(m_GlobalGain)->GetLevel(gain);
 
   570         static_cast<QTMSGlobalGainEffect*> (m_GlobalGain)->GetLevel(gain);
 
   613         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   571         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   614         
   572 
   615         QCOMPARE(gain,maxgain);
 
   573         QCOMPARE(gain,maxgain);
 
   616   
   574 
   617         }
 
   575     }
 
   618     }
 
   576 }
 
   619 
   577 
   620 void QTmsCsTest::CreateRouting_data()
 
   578 void QTmsCsTest::CreateRouting_data()
 
   621     {
 
   579 {
 
   622     gint status;
 
   580     gint status;
 
   623     if (m_Factory && !m_Routing)
 
   581     if (m_Factory && !m_Routing) {
 
   624         {
 
       
   625         status = m_Factory->CreateGlobalRouting(m_Routing);
 
   582         status = m_Factory->CreateGlobalRouting(m_Routing);
 
   626         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   583         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   627 
   584 
   628         m_RoutingSpy = new QSignalSpy(m_Routing,
 
   585         m_RoutingSpy = new QSignalSpy(m_Routing,
 
   629                       SIGNAL(GlobalRoutingEvent(const QTMSGlobalRouting&,
 
   586             SIGNAL(GlobalRoutingEvent(const QTMSGlobalRouting&,
 
   630                               QTMSSignalEvent,
 
   587                     QTMSSignalEvent,
 
   631                               QTMSAudioOutput)));
 
   588                     QTMSAudioOutput)));
 
   632 
   589 
   633         QVERIFY( m_RoutingSpy->isValid() );
 
   590         QVERIFY( m_RoutingSpy->isValid() );
 
   634 
   591 
   635        // QCOMPARE(m_RoutingSpy->count(), 0 );
 
   592         // QCOMPARE(m_RoutingSpy->count(), 0 );
 
   636         connect(m_Routing,
 
   593         connect(m_Routing, SIGNAL(GlobalRoutingEvent(const QTMSGlobalRouting&,
 
   637                 SIGNAL(GlobalRoutingEvent(const QTMSGlobalRouting&,
 
   594                 QTMSSignalEvent,QTMSAudioOutput)), this,
 
   638                         QTMSSignalEvent,QTMSAudioOutput)),
 
   595             SLOT(GlobalRoutingEvent(const QTMSGlobalRouting&,
 
   639                 this,
 
   596                     QTMSSignalEvent,QTMSAudioOutput)));
 
   640                 SLOT(GlobalRoutingEvent(const QTMSGlobalRouting&,
 
   597     }
 
   641                         QTMSSignalEvent,QTMSAudioOutput)));
 
       
   642         }
 
       
   643 
   598 
   644     //Populate data and test based on available output
 
   599     //Populate data and test based on available output
 
   645     GetAvailableOutput();
 
   600     GetAvailableOutput();
 
   646     }
 
   601 }
 
   647 
   602 
   648 void QTmsCsTest::CreateRouting()
 
   603 void QTmsCsTest::CreateRouting()
 
   649     {
 
   604 {
 
   650     gint status(QTMS_RESULT_SUCCESS);
 
   605     gint status(QTMS_RESULT_SUCCESS);
 
   651     
       
   652     QFETCH(QTMSAudioOutput, routing);
 
   606     QFETCH(QTMSAudioOutput, routing);
 
   653     
   607 
   654     if(m_Routing)
 
   608     if (m_Routing) {
 
   655         {
 
       
   656         status = m_Routing->SetOutput(routing);
 
   609         status = m_Routing->SetOutput(routing);
 
   657         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   610         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   658 #ifndef __WINSCW__
 
   611 #ifndef __WINSCW__
 
   659         QTest::qWait(1000);            
   612         QTest::qWait(1000);
 
   660       //  QCOMPARE(m_RoutingSpy->count(), 1 );
 
   613         //  QCOMPARE(m_RoutingSpy->count(), 1 );
 
   661 #endif
 
   614 #endif
 
   662         QTMSAudioOutput current;     
   615         QTMSAudioOutput current;
 
   663         status = m_Routing->GetOutput(current);
 
   616         status = m_Routing->GetOutput(current);
 
   664 
   617 
   665         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   618         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   666         QCOMPARE(routing,current);
 
   619         QCOMPARE(routing,current);
 
   667         
   620 
   668         QTMSAudioOutput previous;
 
   621         QTMSAudioOutput previous;
 
   669         status = m_Routing->GetPreviousOutput(previous);
 
   622         status = m_Routing->GetPreviousOutput(previous);
 
   670         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   623         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
   671         qDebug("Previous routing:");
 
   624         qDebug("Previous routing:");
 
   672         DisplayDevice(previous);
 
   625         DisplayDevice(previous);
 
   673         } 
   626     }
 
   674     }
 
   627 }
 
   675 
   628 
   676 void QTmsCsTest::GetAvailableOutput()
 
   629 void QTmsCsTest::GetAvailableOutput()
 
       
   630 {
 
       
   631     gint status(QTMS_RESULT_SUCCESS);
 
       
   632 
       
   633     if (m_Routing) {
 
       
   634         status = m_Routing->GetAvailableOutputs(m_Availableoutputs);
 
       
   635 
       
   636         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   637 
       
   638         qDebug("Available outputs: %d", m_Availableoutputs.size());
 
       
   639         std::vector<guint>::iterator iteroutputs = m_Availableoutputs.begin();
 
       
   640         for (; iteroutputs < m_Availableoutputs.end(); iteroutputs++) {
 
       
   641             DisplayDevice(*iteroutputs);
 
       
   642         }
 
       
   643     }
 
       
   644 }
 
       
   645 
       
   646 void QTmsCsTest::DisplayDevice(QTMSAudioOutput device)
 
       
   647 {
 
       
   648     QTest::addColumn<QTMSAudioOutput>("routing");
 
       
   649 
       
   650     switch (device) {
 
       
   651     case QTMS_AUDIO_OUTPUT_NONE:
 
   677     {
 
   652     {
 
   678     gint status(QTMS_RESULT_SUCCESS);
 
   653         qDebug("none");
 
   679 
   654         QTest::newRow("None") << QTMS_AUDIO_OUTPUT_NONE;
 
   680     if (m_Routing)
 
   655     }
 
   681         {
 
   656         break;
 
   682         status = m_Routing->GetAvailableOutputs(m_Availableoutputs);
 
   657     case QTMS_AUDIO_OUTPUT_PUBLIC:
 
   683 
       
   684         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   685           
       
   686         qDebug("Available outputs: %d",m_Availableoutputs.size());
 
       
   687         std::vector<guint>::iterator iteroutputs =
 
       
   688                     m_Availableoutputs.begin();
 
       
   689         for (; iteroutputs < m_Availableoutputs.end(); iteroutputs++)
 
       
   690             {
 
       
   691             DisplayDevice(*iteroutputs);
 
       
   692             }
 
       
   693         }
 
       
   694     }
 
       
   695 
       
   696 void QTmsCsTest::DisplayDevice(QTMSAudioOutput device)
 
       
   697     {
 
   658     {
 
   698     QTest::addColumn<QTMSAudioOutput>("routing");
 
   659         qDebug("Public");
 
   699     
   660         QTest::newRow("Public") << QTMS_AUDIO_OUTPUT_PUBLIC;
 
   700     switch (device)
 
   661     }
 
   701         {
 
   662         break;
 
   702         case QTMS_AUDIO_OUTPUT_NONE:
 
   663     case QTMS_AUDIO_OUTPUT_PRIVATE:
 
   703             {
 
   664     {
 
   704             qDebug("none");
 
   665         qDebug("Private");
 
   705             QTest::newRow("None")<<QTMS_AUDIO_OUTPUT_NONE;
 
   666         QTest::newRow("Private") << QTMS_AUDIO_OUTPUT_PRIVATE;
 
   706             }
 
   667     }
 
   707             break;
 
   668         break;
 
   708         case QTMS_AUDIO_OUTPUT_PUBLIC:
 
   669     case QTMS_AUDIO_OUTPUT_HANDSET:
 
   709             {
 
   670     {
 
   710             qDebug("Public");
 
   671         qDebug("Handset");
 
   711             QTest::newRow("Public")<<QTMS_AUDIO_OUTPUT_PUBLIC;
 
   672         QTest::newRow("Handset") << QTMS_AUDIO_OUTPUT_HANDSET;
 
   712             }
 
   673     }
 
   713             break;
 
   674         break;
 
   714         case QTMS_AUDIO_OUTPUT_PRIVATE:
 
   675     case QTMS_AUDIO_OUTPUT_LOUDSPEAKER:
 
   715             {
 
   676     {
 
   716             qDebug("Private");
 
   677         qDebug("Loudspeaker");
 
   717             QTest::newRow("Private")<<QTMS_AUDIO_OUTPUT_PRIVATE;
 
   678         QTest::newRow("Loud speaker") << QTMS_AUDIO_OUTPUT_LOUDSPEAKER;
 
   718             }
 
   679     }
 
   719             break;
 
   680         break;
 
   720         case QTMS_AUDIO_OUTPUT_HANDSET:
 
   681     case QTMS_AUDIO_OUTPUT_WIRED_ACCESSORY:
 
   721             {
 
   682     {
 
   722             qDebug("Handset");
 
   683         qDebug("Wired accessory");
 
   723             QTest::newRow("Handset")<<QTMS_AUDIO_OUTPUT_HANDSET;
 
   684         QTest::newRow("Wired accessory") << QTMS_AUDIO_OUTPUT_WIRED_ACCESSORY;
 
   724             }
 
   685     }
 
   725             break;
 
   686         break;
 
   726         case QTMS_AUDIO_OUTPUT_LOUDSPEAKER:
 
   687     case QTMS_AUDIO_OUTPUT_ACCESSORY:
 
   727             {
 
   688     {
 
   728             qDebug("Loudspeaker");
 
   689         qDebug("Accessory");
 
   729             QTest::newRow("Loud speaker")<< QTMS_AUDIO_OUTPUT_LOUDSPEAKER;
 
   690         QTest::newRow("Accessory") << QTMS_AUDIO_OUTPUT_ACCESSORY;
 
   730             }
 
   691     }
 
   731             break;
 
   692         break;
 
   732         case QTMS_AUDIO_OUTPUT_WIRED_ACCESSORY:
 
   693     case QTMS_AUDIO_OUTPUT_ETTY:
 
   733             {
 
   694     {
 
   734             qDebug("Wired accessory");
 
   695         qDebug("TTY");
 
   735             QTest::newRow("Wired accessory")<<QTMS_AUDIO_OUTPUT_WIRED_ACCESSORY;
 
   696         QTest::newRow("ETTY") << QTMS_AUDIO_OUTPUT_ETTY;
 
   736             }
 
   697     }
 
   737             break;
 
   698         break;
 
   738         case QTMS_AUDIO_OUTPUT_ACCESSORY:
 
   699     default:
 
   739             {
 
   700         break;
 
   740             qDebug("Accessory");
 
   701     }
 
   741             QTest::newRow("Accessory")<< QTMS_AUDIO_OUTPUT_ACCESSORY;
 
   702 }
 
   742             }
 
   703 
   743             break;
 
   704 void QTmsCsTest::CreateDnlinkDtmf()
 
   744         case QTMS_AUDIO_OUTPUT_ETTY:
 
   705 {
 
   745             {
 
   706     gint status(QTMS_RESULT_SUCCESS);
 
   746             qDebug("TTY");
 
   707     GString* dtmfstring(NULL);
 
   747             QTest::newRow("ETTY")<< QTMS_AUDIO_OUTPUT_ETTY;
 
   708 
   748             }
 
   709     status = m_Factory->CreateDTMF(QTMS_STREAM_DOWNLINK, m_Dnlnkdtmf);
 
       
   710 
       
   711     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   712     if (m_Dnlnkdtmf) {
 
       
   713         QSignalSpy dtmfspy(m_Dnlnkdtmf, SIGNAL(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)));
 
       
   714 
       
   715         QVERIFY( dtmfspy.isValid() );
 
       
   716 
       
   717         //QCOMPARE(dtmfspy.count(), 0 );
 
       
   718 
       
   719         connect(m_Dnlnkdtmf, SIGNAL(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)), this,
 
       
   720             SLOT(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)));
 
       
   721 
       
   722         dtmfstring = g_string_new("4723");
 
       
   723         status = m_Dnlnkdtmf->SetTone(dtmfstring);
 
       
   724 
       
   725         m_Dnlnkdtmf->Start();
 
       
   726         QTest::qWait(1000);
 
       
   727         g_string_free(dtmfstring, TRUE);
 
       
   728         //QCOMPARE(dtmfspy.count(), 1 );
 
       
   729 
       
   730         status = m_Dnlnkdtmf->Stop();
 
       
   731         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   732         QTest::qWait(1000);
 
       
   733         //QCOMPARE(dtmfspy.count(), 2 );
 
       
   734 
       
   735     }
 
       
   736 }
 
       
   737 
       
   738 void QTmsCsTest::CreateUplinkDtmf()
 
       
   739 {
 
       
   740     gint status(QTMS_RESULT_SUCCESS);
 
       
   741     GString* dtmfstring(NULL);
 
       
   742 
       
   743     status = m_Factory->CreateDTMF(QTMS_STREAM_UPLINK, m_Uplnkdtmf);
 
       
   744 
       
   745     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   746     if (m_Uplnkdtmf) {
 
       
   747         QSignalSpy uplinkdtmfspy(m_Uplnkdtmf, SIGNAL(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)));
 
       
   748 
       
   749         QVERIFY( uplinkdtmfspy.isValid() );
 
       
   750 
       
   751         //QCOMPARE(dtmfspy.count(), 0 );
 
       
   752 
       
   753         connect(m_Uplnkdtmf, SIGNAL(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)), this,
 
       
   754             SLOT(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)));
 
       
   755 
       
   756         dtmfstring = g_string_new("4723");
 
       
   757         status = m_Uplnkdtmf->SetTone(dtmfstring);
 
       
   758 
       
   759         m_Uplnkdtmf->Start();
 
       
   760         QTest::qWait(1000);
 
       
   761         g_string_free(dtmfstring, TRUE);
 
       
   762         //QCOMPARE(dtmfspy.count(), 1 );
 
       
   763 
       
   764         m_Uplnkdtmf->ContinueDTMFStringSending(FALSE);
 
       
   765 
       
   766         status = m_Uplnkdtmf->Stop();
 
       
   767         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   768         QTest::qWait(1000);
 
       
   769         //QCOMPARE(dtmfspy.count(), 2 );
 
       
   770 
       
   771     }
 
       
   772 }
 
       
   773 
       
   774 void QTmsCsTest::CreateInband_data()
 
       
   775 {
 
       
   776 
       
   777     gint status(QTMS_RESULT_SUCCESS);
 
       
   778     if (m_Factory && !m_InbandTonePlayer) {
 
       
   779         status = m_Factory->CreateInbandTonePlayer(m_InbandTonePlayer);
 
       
   780 
       
   781         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   782         m_InbandSpy = new QSignalSpy(m_InbandTonePlayer,
 
       
   783             SIGNAL(InbandToneEvent(const QTMSInbandTone&,QTMSSignalEvent)));
 
       
   784 
       
   785         QVERIFY( m_InbandSpy->isValid() );
 
       
   786 
       
   787         //QCOMPARE(m_InbandSpy->count(), 0 );
 
       
   788         connect(m_InbandTonePlayer,
 
       
   789             SIGNAL(InbandToneEvent(const QTMSInbandTone&, QTMSSignalEvent)), this,
 
       
   790             SLOT(InbandToneEvent(const QTMSInbandTone&, QTMSSignalEvent)));
 
       
   791     }
 
       
   792 
       
   793     QTest::addColumn<QTMSInbandToneType>("inbandTone");
 
       
   794 
       
   795     QTest::newRow("Busy") << QTMS_INBAND_USER_BUSY;
 
       
   796     QTest::newRow("Path not avail") << QTMS_INBAND_RADIO_PATH_NOT_AVAIL;
 
       
   797     QTest::newRow("Congestion") << QTMS_INBAND_CONGESTION;
 
       
   798     QTest::newRow("Special info") << QTMS_INBAND_SPECIAL_INFO;
 
       
   799     QTest::newRow("Reorder") << QTMS_INBAND_REORDER;
 
       
   800     QTest::newRow("Remote alerting") << QTMS_INBAND_REMOTE_ALEARTING;
 
       
   801     QTest::newRow("call waiting") << QTMS_INBAND_CALL_WAITING;
 
       
   802     QTest::newRow("data call") << QTMS_INBAND_DATA_CALL;
 
       
   803     QTest::newRow("no sequence") << QTMS_INBAND_NO_SEQUENCE;
 
       
   804     QTest::newRow("beep sequence") << QTMS_INBAND_BEEP_SEQUENCE;
 
       
   805 
       
   806 }
 
       
   807 
       
   808 void QTmsCsTest::CreateInband()
 
       
   809 {
 
       
   810     gint status(QTMS_RESULT_SUCCESS);
 
       
   811     QFETCH(QTMSInbandToneType, inbandTone);
 
       
   812 
       
   813     if (m_InbandTonePlayer) {
 
       
   814         status = m_InbandTonePlayer->Start(inbandTone);
 
       
   815         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   816         QTest::qWait(1000);
 
       
   817         // QCOMPARE(m_InbandSpy->count(), 1 );
 
       
   818 
       
   819         status = m_InbandTonePlayer->Stop();
 
       
   820         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   821         QTest::qWait(1000);
 
       
   822         // QCOMPARE(m_InbandSpy->count(), 2 );
 
       
   823     }
 
       
   824 }
 
       
   825 
       
   826 void QTmsCsTest::CreateRingTone()
 
       
   827 {
 
       
   828     gint status(QTMS_RESULT_SUCCESS);
 
       
   829 
       
   830     if (m_Factory) {
 
       
   831         status = m_Factory->CreateRingTonePlayer(m_RingTonePlayer);
 
       
   832         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   833 
       
   834         connect(m_RingTonePlayer, SIGNAL(RingtoneEvent(const QTMSRingTone&,QTMSSignalEvent)), this,
 
       
   835             SLOT(RingtoneEvent(const QTMSRingTone&,QTMSSignalEvent)));
 
       
   836     }
 
       
   837 
       
   838 }
 
       
   839 
       
   840 void QTmsCsTest::InitRingTonePlayerFromProfiles()
 
       
   841 {
 
       
   842     if (m_RingTonePlayer) {
 
       
   843         gint status = m_RingTonePlayer->Init(QTMS_RINGTONE_DEFAULT);
 
       
   844         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   845         QTest::qWait(1000);
 
       
   846     }
 
       
   847 
       
   848 }
 
       
   849 
       
   850 void QTmsCsTest::InitRingTonePlayerFromFile()
 
       
   851 {
 
       
   852     if (m_RingTonePlayer) {
 
       
   853         TBuf<sizeof(KTestFile1)> buf(KTestFile1);
 
       
   854         m_RTStr = g_string_new_len((gchar*) buf.Ptr(), buf.Length() * 2);
 
       
   855         gint status = m_RingTonePlayer->Init(QTMS_RINGTONE_FILE, m_RTStr);
 
       
   856         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   857         QTest::qWait(1000);
 
       
   858         g_string_free(m_RTStr, TRUE);
 
       
   859         m_RTStr = NULL;
 
       
   860     }
 
       
   861 
       
   862 }
 
       
   863 
       
   864 void QTmsCsTest::InitRingToneSequencePlayer()
 
       
   865 {
 
       
   866     if (m_RingTonePlayer) {
 
       
   867         TBuf8<sizeof(KRTBeepSequence)> buf(KRTBeepSequence);
 
       
   868         m_RTStr = g_string_new_len((gchar*) buf.Ptr(), buf.Length());
 
       
   869         gint status = m_RingTonePlayer->Init(QTMS_RINGTONE_SEQUENCE, m_RTStr);
 
       
   870         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   871         QTest::qWait(1000);
 
       
   872         g_string_free(m_RTStr, TRUE);
 
       
   873     }
 
       
   874 }
 
       
   875 
       
   876 void QTmsCsTest::PlayRingTone()
 
       
   877 {
 
       
   878     if (m_RingTonePlayer) {
 
       
   879         gint status = m_RingTonePlayer->Play();
 
       
   880         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   881         QTest::qWait(1000);
 
       
   882     }
 
       
   883 }
 
       
   884 
       
   885 void QTmsCsTest::PauseRingTone()
 
       
   886 {
 
       
   887     if (m_RingTonePlayer) {
 
       
   888         gint status = m_RingTonePlayer->Pause(); //pause audio for video RT only
 
       
   889         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   890         QTest::qWait(1000);
 
       
   891     }
 
       
   892 }
 
       
   893 
       
   894 void QTmsCsTest::StopRingTone()
 
       
   895 {
 
       
   896     if (m_RingTonePlayer) {
 
       
   897         gint status = m_RingTonePlayer->Stop();
 
       
   898         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   899         QTest::qWait(1000);
 
       
   900     }
 
       
   901 }
 
       
   902 
       
   903 void QTmsCsTest::MuteRingTone()
 
       
   904 {
 
       
   905     if (m_RingTonePlayer) {
 
       
   906         m_RingTonePlayer->Mute();
 
       
   907     }
 
       
   908 }
 
       
   909 
       
   910 void QTmsCsTest::CloseRingTonePlayer()
 
       
   911 {
 
       
   912     if (m_Factory && m_RingTonePlayer) {
 
       
   913         m_RingTonePlayer->Deinit();
 
       
   914         m_Factory->DeleteRingTonePlayer(m_RingTonePlayer);
 
       
   915     }
 
       
   916 }
 
       
   917 
       
   918 void QTmsCsTest::EffectsEvent(const QTMSEffect& tmseffect, QTMSSignalEvent event)
 
       
   919 {
 
       
   920     QTMSEffectType effecttype;
 
       
   921     const_cast<QTMSEffect&> (tmseffect).GetType(effecttype);
 
       
   922 
       
   923     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
       
   924 
       
   925     switch (effecttype) {
 
       
   926     case TMS_EFFECT_GLOBAL_VOL:
 
       
   927     {
 
       
   928         switch (event.type) {
 
       
   929         case TMS_EVENT_EFFECT_VOL_CHANGED:
 
       
   930             qDebug("Global vol effect change");
 
   749             break;
 
   931             break;
 
   750         default:
 
   932         default:
 
   751             break;
 
   933             break;
 
   752         }
 
   934         }
 
   753     }
 
   935     }
 
   754 
   936         break;
 
   755 void QTmsCsTest::CreateDnlinkDtmf()
 
   937     case TMS_EFFECT_GLOBAL_GAIN:
 
   756     {
 
   938     {
 
   757     gint status(QTMS_RESULT_SUCCESS);
 
   939         switch (event.type) {
 
   758     GString* dtmfstring(NULL);
 
   940         case TMS_EVENT_EFFECT_GAIN_CHANGED:
 
   759 
   941             qDebug("Global gain effect change");
 
   760     status = m_Factory->CreateDTMF(QTMS_STREAM_DOWNLINK, m_Dnlnkdtmf);
 
       
   761 
       
   762     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   763     if (m_Dnlnkdtmf)
 
       
   764         {
 
       
   765         QSignalSpy dtmfspy(m_Dnlnkdtmf,
 
       
   766                 SIGNAL(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)));
 
       
   767 
       
   768         QVERIFY( dtmfspy.isValid() );
 
       
   769 
       
   770         //QCOMPARE(dtmfspy.count(), 0 );
 
       
   771         
       
   772         connect(m_Dnlnkdtmf,
 
       
   773                 SIGNAL(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)), this,
 
       
   774                 SLOT(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)));
 
       
   775 
       
   776         dtmfstring = g_string_new("4723");
 
       
   777         status = m_Dnlnkdtmf->SetTone(dtmfstring);
 
       
   778        
       
   779         m_Dnlnkdtmf->Start();
 
       
   780         QTest::qWait(1000);
 
       
   781         g_string_free(dtmfstring, TRUE);
 
       
   782         //QCOMPARE(dtmfspy.count(), 1 );
 
       
   783         
       
   784         status = m_Dnlnkdtmf->Stop();
 
       
   785         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   786         QTest::qWait(1000);
 
       
   787         //QCOMPARE(dtmfspy.count(), 2 );
 
       
   788 
       
   789         }
 
       
   790     }
 
       
   791 
       
   792 void QTmsCsTest::CreateUplinkDtmf()
 
       
   793     {
 
       
   794     gint status(QTMS_RESULT_SUCCESS);
 
       
   795     GString* dtmfstring(NULL);
 
       
   796 
       
   797     status = m_Factory->CreateDTMF(QTMS_STREAM_UPLINK, m_Uplnkdtmf);
 
       
   798 
       
   799     QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   800     if (m_Uplnkdtmf)
 
       
   801         {
 
       
   802         QSignalSpy uplinkdtmfspy(m_Uplnkdtmf,
 
       
   803                 SIGNAL(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)));
 
       
   804 
       
   805         QVERIFY( uplinkdtmfspy.isValid() );
 
       
   806 
       
   807         //QCOMPARE(dtmfspy.count(), 0 );
 
       
   808         
       
   809         connect(m_Uplnkdtmf,
 
       
   810                 SIGNAL(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)), this,
 
       
   811                 SLOT(DTMFEvent(const QTMSDTMF&,QTMSSignalEvent)));
 
       
   812 
       
   813         dtmfstring = g_string_new("4723");
 
       
   814         status = m_Uplnkdtmf->SetTone(dtmfstring);
 
       
   815        
       
   816         m_Uplnkdtmf->Start();
 
       
   817         QTest::qWait(1000);
 
       
   818         g_string_free(dtmfstring, TRUE);
 
       
   819         //QCOMPARE(dtmfspy.count(), 1 );
 
       
   820         
       
   821         m_Uplnkdtmf->ContinueDTMFStringSending(FALSE);
 
       
   822         
       
   823         status = m_Uplnkdtmf->Stop();
 
       
   824         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   825         QTest::qWait(1000);
 
       
   826         //QCOMPARE(dtmfspy.count(), 2 );
 
       
   827 
       
   828         }
 
       
   829     }
 
       
   830 
       
   831 
       
   832 void QTmsCsTest::CreateInband_data()
 
       
   833     {  
       
   834     
       
   835     gint status(QTMS_RESULT_SUCCESS);
 
       
   836     if (m_Factory && !m_InbandTonePlayer)
 
       
   837         {
 
       
   838         status = m_Factory->CreateInbandTonePlayer(m_InbandTonePlayer);
 
       
   839 
       
   840         QVERIFY(status == QTMS_RESULT_SUCCESS);           
       
   841         m_InbandSpy  = new QSignalSpy(m_InbandTonePlayer,
 
       
   842                         SIGNAL(InbandToneEvent(const QTMSInbandTone&,QTMSSignalEvent)));
 
       
   843 
       
   844         QVERIFY( m_InbandSpy->isValid() );
 
       
   845 
       
   846         //QCOMPARE(m_InbandSpy->count(), 0 );
 
       
   847         connect(m_InbandTonePlayer,
 
       
   848                 SIGNAL(InbandToneEvent(const QTMSInbandTone&, QTMSSignalEvent)),
 
       
   849                 this,
 
       
   850                 SLOT(InbandToneEvent(const QTMSInbandTone&, QTMSSignalEvent)));
 
       
   851         }
 
       
   852     
       
   853     QTest::addColumn<QTMSInbandToneType>("inbandTone");
 
       
   854 
       
   855     QTest::newRow("Busy")<<QTMS_INBAND_USER_BUSY;
 
       
   856     QTest::newRow("Path not avail")<<QTMS_INBAND_RADIO_PATH_NOT_AVAIL;
 
       
   857     QTest::newRow("Congestion")<< QTMS_INBAND_CONGESTION;   
       
   858     QTest::newRow("Special info")<<QTMS_INBAND_SPECIAL_INFO;
 
       
   859     QTest::newRow("Reorder")<< QTMS_INBAND_REORDER;
 
       
   860     QTest::newRow("Remote alerting")<<QTMS_INBAND_REMOTE_ALEARTING;
 
       
   861     QTest::newRow("call waiting")<< QTMS_INBAND_CALL_WAITING;
 
       
   862     QTest::newRow("data call")<< QTMS_INBAND_DATA_CALL;
 
       
   863     QTest::newRow("no sequence")<< QTMS_INBAND_NO_SEQUENCE;  
       
   864     QTest::newRow("beep sequence")<<QTMS_INBAND_BEEP_SEQUENCE;
 
       
   865   
       
   866     }
 
       
   867 
       
   868 
       
   869 void QTmsCsTest::CreateInband()
 
       
   870     {
 
       
   871     gint status(QTMS_RESULT_SUCCESS);
 
       
   872     QFETCH(QTMSInbandToneType, inbandTone);
 
       
   873 
       
   874     if (m_InbandTonePlayer)
 
       
   875         {
 
       
   876         status = m_InbandTonePlayer->Start(inbandTone);
 
       
   877         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   878         QTest::qWait(1000);
 
       
   879         // QCOMPARE(m_InbandSpy->count(), 1 );
 
       
   880 
       
   881         status = m_InbandTonePlayer->Stop();
 
       
   882         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   883         QTest::qWait(1000);
 
       
   884         // QCOMPARE(m_InbandSpy->count(), 2 );
 
       
   885         }
 
       
   886     }
 
       
   887 
       
   888 
       
   889 void QTmsCsTest::CreateRingTone()
 
       
   890     {
 
       
   891     gint status(QTMS_RESULT_SUCCESS);
 
       
   892 
       
   893     if (m_Factory)
 
       
   894         {
 
       
   895         status = m_Factory->CreateRingTonePlayer(m_RingTonePlayer);
 
       
   896         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   897 
       
   898         connect(m_RingTonePlayer,
 
       
   899                 SIGNAL(RingtoneEvent(const QTMSRingTone&,QTMSSignalEvent)),
 
       
   900                 this,
 
       
   901                 SLOT(RingtoneEvent(const QTMSRingTone&,QTMSSignalEvent)));
 
       
   902         }
 
       
   903 
       
   904     }
 
       
   905 
       
   906 void QTmsCsTest::InitRingTonePlayerFromProfiles()
 
       
   907     {
 
       
   908     if (m_RingTonePlayer)
 
       
   909         {
 
       
   910         gint status = m_RingTonePlayer->Init(QTMS_RINGTONE_DEFAULT);
 
       
   911         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   912         QTest::qWait(1000);
 
       
   913         }
 
       
   914  
       
   915     }
 
       
   916 
       
   917 void QTmsCsTest::InitRingTonePlayerFromFile()
 
       
   918     {
 
       
   919     if (m_RingTonePlayer)
 
       
   920         {
 
       
   921         TBuf<sizeof(KTestFile1)> buf(KTestFile1);
 
       
   922         m_RTStr = g_string_new_len((gchar*) buf.Ptr(), buf.Length() * 2);
 
       
   923         gint status = m_RingTonePlayer->Init(QTMS_RINGTONE_FILE, m_RTStr);
 
       
   924         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   925         QTest::qWait(1000);
 
       
   926         g_string_free(m_RTStr, TRUE);
 
       
   927         m_RTStr = NULL;
 
       
   928         }
 
       
   929 
       
   930     }
 
       
   931 
       
   932 
       
   933 void QTmsCsTest::InitRingToneSequencePlayer()
 
       
   934     {
 
       
   935     if (m_RingTonePlayer)
 
       
   936         {
 
       
   937         TBuf8<sizeof(KRTBeepSequence)> buf(KRTBeepSequence);
 
       
   938         m_RTStr = g_string_new_len((gchar*) buf.Ptr(), buf.Length());
 
       
   939         gint status = m_RingTonePlayer->Init(QTMS_RINGTONE_SEQUENCE, m_RTStr);
 
       
   940         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   941         QTest::qWait(1000);
 
       
   942         g_string_free(m_RTStr, TRUE);
 
       
   943         }
 
       
   944     }
 
       
   945 
       
   946 
       
   947 void QTmsCsTest::PlayRingTone()
 
       
   948     {
 
       
   949     if (m_RingTonePlayer)
 
       
   950         {
 
       
   951         gint status = m_RingTonePlayer->Play();
 
       
   952         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   953         QTest::qWait(1000);
 
       
   954         }
 
       
   955     }
 
       
   956 
       
   957 
       
   958 void QTmsCsTest::PauseRingTone()
 
       
   959     {
 
       
   960     if (m_RingTonePlayer)
 
       
   961         {
 
       
   962         gint status = m_RingTonePlayer->Pause(); //pause audio for video RT only
 
       
   963         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   964         QTest::qWait(1000);
 
       
   965         }
 
       
   966     }
 
       
   967 
       
   968 
       
   969 void QTmsCsTest::StopRingTone()
 
       
   970     {
 
       
   971     if (m_RingTonePlayer)
 
       
   972         {
 
       
   973         gint status = m_RingTonePlayer->Stop();
 
       
   974         QVERIFY(status == QTMS_RESULT_SUCCESS);
 
       
   975         QTest::qWait(1000);
 
       
   976         }
 
       
   977     }
 
       
   978 
       
   979 
       
   980 void QTmsCsTest::MuteRingTone()
 
       
   981     {
 
       
   982     if (m_RingTonePlayer)
 
       
   983         {
 
       
   984         m_RingTonePlayer->Mute();
 
       
   985         }
 
       
   986     }
 
       
   987 
       
   988 void QTmsCsTest::CloseRingTonePlayer()
 
       
   989     {
 
       
   990     if (m_Factory && m_RingTonePlayer)
 
       
   991         {
 
       
   992         m_RingTonePlayer->Deinit();
 
       
   993         m_Factory->DeleteRingTonePlayer(m_RingTonePlayer);
 
       
   994         }
 
       
   995     }
 
       
   996 
       
   997 void QTmsCsTest::EffectsEvent(const QTMSEffect& tmseffect,
 
       
   998         QTMSSignalEvent event)
 
       
   999     {
 
       
  1000     QTMSEffectType effecttype;
 
       
  1001     const_cast<QTMSEffect&> (tmseffect).GetType(effecttype);
 
       
  1002 
       
  1003     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
       
  1004     
       
  1005     switch (effecttype)
 
       
  1006         {
 
       
  1007         case TMS_EFFECT_GLOBAL_VOL:
 
       
  1008             {
 
       
  1009             switch (event.type)
 
       
  1010                 {
 
       
  1011                 case TMS_EVENT_EFFECT_VOL_CHANGED:
 
       
  1012                     qDebug("Global vol effect change");
 
       
  1013                     break;
 
       
  1014                 default:
 
       
  1015                     break;
 
       
  1016                 }
 
       
  1017             }
 
       
  1018             break;
 
       
  1019         case TMS_EFFECT_GLOBAL_GAIN:
 
       
  1020             {
 
       
  1021             switch (event.type)
 
       
  1022                 {
 
       
  1023                 case TMS_EVENT_EFFECT_GAIN_CHANGED:
 
       
  1024                     qDebug("Global gain effect change");
 
       
  1025                     break;
 
       
  1026                 default:
 
       
  1027                     break;
 
       
  1028                 }
 
       
  1029             }
 
       
  1030             break;
 
       
  1031         case TMS_EFFECT_VOLUME:
 
       
  1032             qDebug("Stream vol effect change");
 
       
  1033             break;
 
       
  1034         case TMS_EFFECT_GAIN:
 
       
  1035             qDebug("Stream gain effect change");
 
       
  1036             break;
 
   942             break;
 
  1037         default:
 
   943         default:
 
  1038             break;
 
   944             break;
 
  1039         }
 
   945         }
 
  1040     }
 
   946     }
 
  1041 
   947         break;
 
  1042 
   948     case TMS_EFFECT_VOLUME:
 
  1043 void QTmsCsTest::GlobalRoutingEvent(const QTMSGlobalRouting& /*routing*/,
 
   949         qDebug("Stream vol effect change");
 
  1044         QTMSSignalEvent event, QTMSAudioOutput /*output*/)
 
   950         break;
 
  1045     {
 
   951     case TMS_EFFECT_GAIN:
 
       
   952         qDebug("Stream gain effect change");
 
       
   953         break;
 
       
   954     default:
 
       
   955         break;
 
       
   956     }
 
       
   957 }
 
       
   958 
       
   959 void QTmsCsTest::GlobalRoutingEvent(const QTMSGlobalRouting& /*routing*/, QTMSSignalEvent event,
 
       
   960     QTMSAudioOutput /*output*/)
 
       
   961 {
 
  1046     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
   962     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
  1047     switch (event.type)
 
   963     switch (event.type) {
 
  1048         {
 
   964     case TMS_EVENT_ROUTING_AVAIL_OUTPUTS_CHANGED:
 
  1049         case TMS_EVENT_ROUTING_AVAIL_OUTPUTS_CHANGED:
 
   965         qDebug("Available outputs changed");
 
  1050             qDebug("Available outputs changed");
 
   966         break;
 
  1051             break;
 
   967     case TMS_EVENT_ROUTING_OUTPUT_CHANGED:
 
  1052         case TMS_EVENT_ROUTING_OUTPUT_CHANGED:
 
   968         qDebug("output changed");
 
  1053             qDebug("output changed");
 
   969         break;
 
  1054             break;
 
   970     case TMS_EVENT_ROUTING_SET_OUTPUT_COMPLETE:
 
  1055         case TMS_EVENT_ROUTING_SET_OUTPUT_COMPLETE:
 
   971         qDebug("set output complete");
 
  1056             qDebug("set output complete");
 
   972         break;
 
  1057             break;
 
   973     default:
 
  1058         default:
 
   974         break;
 
  1059             break;
 
   975     }
 
  1060         }
 
   976 
  1061     
   977 }
 
  1062     }
 
   978 
  1063 
   979 void QTmsCsTest::TMSStreamEvent(const QTMSStream& stream, QTMSSignalEvent event)
 
  1064 void QTmsCsTest::TMSStreamEvent(const QTMSStream& stream,
 
   980 {
 
  1065         QTMSSignalEvent event)
 
   981 
  1066     {
 
       
  1067     
       
  1068     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
   982     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
  1069     
   983 
  1070     gint streamId;
 
   984     gint streamId;
 
  1071     streamId = const_cast<QTMSStream&> (stream).GetStreamId();
 
   985     streamId = const_cast<QTMSStream&> (stream).GetStreamId();
 
  1072     qDebug("StreamID %d",streamId);
 
   986     qDebug("StreamID %d", streamId);
 
  1073     gint state;
 
   987     gint state;
 
  1074     state = const_cast<QTMSStream&> (stream).GetState();
 
   988     state = const_cast<QTMSStream&> (stream).GetState();
 
  1075     QVERIFY(state == event.curr_state);
 
   989     QVERIFY(state == event.curr_state);
 
  1076 
   990 
  1077     switch (const_cast<QTMSStream&> (stream).GetStreamType())
 
   991     switch (const_cast<QTMSStream&> (stream).GetStreamType()) {
 
       
   992     case QTMS_STREAM_UPLINK:
 
       
   993     {
 
       
   994         switch (event.type) {
 
       
   995         case QTMS_EVENT_STREAM_STATE_CHANGED:
 
  1078         {
 
   996         {
 
  1079         case QTMS_STREAM_UPLINK:
 
   997             switch (event.curr_state) {
 
       
   998             case QTMS_STREAM_INITIALIZED:
 
  1080             {
 
   999             {
 
  1081             switch (event.type)
 
  1000                 qDebug("Uplink initialized ");
 
  1082                 {
 
  1001                 break;
 
  1083                 case QTMS_EVENT_STREAM_STATE_CHANGED:
 
  1002             }
 
  1084                     {
 
  1003             case QTMS_STREAM_UNINITIALIZED:
 
  1085                     switch (event.curr_state)
 
  1004                 qDebug("Uplink uninitialized ");
 
  1086                         {
 
  1005                 break;
 
  1087                         case QTMS_STREAM_INITIALIZED:
 
  1006             case QTMS_STREAM_PAUSED:
 
  1088                             {
 
  1007                 qDebug("Uplink paused ");
 
  1089                             qDebug("Uplink initialized ");
 
  1008                 break;
 
  1090                             break;
 
  1009             case QTMS_STREAM_STARTED:
 
  1091                             }
 
  1010                 qDebug("Uplink started ");
 
  1092                         case QTMS_STREAM_UNINITIALIZED:
 
  1011                 break;
 
  1093                             qDebug("Uplink uninitialized ");
 
  1012             default:
 
  1094                             break;
 
  1013                 break;
 
  1095                         case QTMS_STREAM_PAUSED:
 
  1014             }
 
  1096                             qDebug("Uplink paused ");
 
       
  1097                             break;
 
       
  1098                         case QTMS_STREAM_STARTED:
 
       
  1099                             qDebug("Uplink started ");
 
       
  1100                             break;
 
       
  1101                         default:
 
       
  1102                             break;
 
       
  1103                         }
 
       
  1104                     break;
 
       
  1105                     }
 
       
  1106                 default:
 
       
  1107                     break;
 
       
  1108                 }
 
       
  1109             break;
 
  1015             break;
 
  1110             }
 
  1016         }
 
  1111         case QTMS_STREAM_DOWNLINK:
 
       
  1112             {
 
       
  1113             switch (event.type)
 
       
  1114                 {
 
       
  1115                 case QTMS_EVENT_STREAM_STATE_CHANGED:
 
       
  1116                     {
 
       
  1117                     switch (event.curr_state)
 
       
  1118                         {
 
       
  1119                         case QTMS_STREAM_INITIALIZED:
 
       
  1120                             {
 
       
  1121                             qDebug("Downlink initialized ");
 
       
  1122                             break;
 
       
  1123                             }
 
       
  1124                         case QTMS_STREAM_UNINITIALIZED:
 
       
  1125                             qDebug("Downlink uninitialized ");
 
       
  1126                             break;
 
       
  1127                         case QTMS_STREAM_PAUSED:
 
       
  1128                             qDebug("Downlink paused ");
 
       
  1129                             break;
 
       
  1130                         case QTMS_STREAM_STARTED:
 
       
  1131                             qDebug("Downlink started ");
 
       
  1132                             break;
 
       
  1133                         default:
 
       
  1134                             break;
 
       
  1135                         }
 
       
  1136                     break;
 
       
  1137                     }
 
       
  1138                 default:
 
       
  1139                     break;
 
       
  1140                 }
 
       
  1141             break;
 
       
  1142             }
 
       
  1143         default:
 
  1017         default:
 
  1144             break;
 
  1018             break;
 
  1145         }
 
  1019         }
 
  1146     }
 
  1020         break;
 
  1147 
  1021     }
 
  1148 
  1022     case QTMS_STREAM_DOWNLINK:
 
  1149 void QTmsCsTest::RingtoneEvent(const QTMSRingTone& /*rt*/,
 
       
  1150         QTMSSignalEvent event)
 
       
  1151     {
 
  1023     {
 
  1152     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
  1024         switch (event.type) {
 
  1153     switch (event.type)
 
  1025         case QTMS_EVENT_STREAM_STATE_CHANGED:
 
  1154         {
 
  1026         {
 
  1155         case TMS_EVENT_RINGTONE_OPEN_COMPLETE:
 
  1027             switch (event.curr_state) {
 
  1156             qDebug("RT Open Complete");
 
  1028             case QTMS_STREAM_INITIALIZED:
 
       
  1029             {
 
       
  1030                 qDebug("Downlink initialized ");
 
       
  1031                 break;
 
       
  1032             }
 
       
  1033             case QTMS_STREAM_UNINITIALIZED:
 
       
  1034                 qDebug("Downlink uninitialized ");
 
       
  1035                 break;
 
       
  1036             case QTMS_STREAM_PAUSED:
 
       
  1037                 qDebug("Downlink paused ");
 
       
  1038                 break;
 
       
  1039             case QTMS_STREAM_STARTED:
 
       
  1040                 qDebug("Downlink started ");
 
       
  1041                 break;
 
       
  1042             default:
 
       
  1043                 break;
 
       
  1044             }
 
  1157             break;
 
  1045             break;
 
  1158         case TMS_EVENT_RINGTONE_PLAY_COMPLETE:
 
  1046         }
 
  1159             qDebug("RT Play Complete");
 
       
  1160             break;
 
       
  1161         default:
 
  1047         default:
 
  1162             break;
 
  1048             break;
 
  1163         }
 
  1049         }
 
  1164     }
 
  1050         break;
 
  1165 
  1051     }
 
       
  1052     default:
 
       
  1053         break;
 
       
  1054     }
 
       
  1055 }
 
       
  1056 
       
  1057 void QTmsCsTest::RingtoneEvent(const QTMSRingTone& /*rt*/, QTMSSignalEvent event)
 
       
  1058 {
 
       
  1059     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
       
  1060     switch (event.type) {
 
       
  1061     case TMS_EVENT_RINGTONE_OPEN_COMPLETE:
 
       
  1062         qDebug("RT Open Complete");
 
       
  1063         break;
 
       
  1064     case TMS_EVENT_RINGTONE_PLAY_COMPLETE:
 
       
  1065         qDebug("RT Play Complete");
 
       
  1066         break;
 
       
  1067     default:
 
       
  1068         break;
 
       
  1069     }
 
       
  1070 }
 
  1166 
  1071 
  1167 void QTmsCsTest::DTMFEvent(const QTMSDTMF& /*dtmf*/, QTMSSignalEvent event)
 
  1072 void QTmsCsTest::DTMFEvent(const QTMSDTMF& /*dtmf*/, QTMSSignalEvent event)
 
  1168     {
 
  1073 {
 
  1169     if(event.reason!= QTMS_RESULT_SUCCESS)
 
  1074     if (event.reason != QTMS_RESULT_SUCCESS) {
 
  1170         {
 
       
  1171         QEXPECT_FAIL("","Need to be in call, expect uplink dtmf to fail", Continue);
 
  1075         QEXPECT_FAIL("","Need to be in call, expect uplink dtmf to fail", Continue);
 
  1172         }
 
  1076     }
 
  1173     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
  1077     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
  1174     
  1078 
  1175     switch (event.type)
 
  1079     switch (event.type) {
 
  1176         {
 
  1080     case QTMS_EVENT_DTMF_TONE_STARTED:
 
  1177         case QTMS_EVENT_DTMF_TONE_STARTED:
 
  1081         qDebug("DTMF Started");
 
  1178             qDebug("DTMF Started");
 
  1082         break;
 
  1179             break;
 
  1083     case QTMS_EVENT_DTMF_TONE_STOPPED:
 
  1180         case QTMS_EVENT_DTMF_TONE_STOPPED:
 
  1084         qDebug("DTMF Stopped");
 
  1181             qDebug("DTMF Stopped");
 
  1085         break;
 
  1182             break;
 
  1086     default:
 
  1183         default:
 
  1087         break;
 
  1184             break;
 
  1088     }
 
  1185         }
 
  1089 }
 
  1186     }
 
  1090 
  1187 
  1091 void QTmsCsTest::InbandToneEvent(const QTMSInbandTone& /*inbandtone*/, QTMSSignalEvent event)
 
  1188 void QTmsCsTest::InbandToneEvent(const QTMSInbandTone& /*inbandtone*/,
 
  1092 {
 
  1189         QTMSSignalEvent event)
 
       
  1190     {
 
       
  1191     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
  1093     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);
 
  1192     switch (event.type)
 
  1094     switch (event.type) {
 
  1193         {
 
  1095     case QTMS_EVENT_INBAND_TONE_STARTED:
 
  1194         case QTMS_EVENT_INBAND_TONE_STARTED:
 
  1096         qDebug("Inband Tone Started");
 
  1195             qDebug("Inband Tone Started");
 
  1097         break;
 
  1196             break;
 
  1098     case QTMS_EVENT_INBAND_TONE_STOPPED:
 
  1197         case QTMS_EVENT_INBAND_TONE_STOPPED:
 
  1099         qDebug("Inband Tone Stopped");
 
  1198             qDebug("Inband Tone Stopped");
 
  1100         break;
 
  1199             break;
 
  1101     default:
 
  1200         default:
 
  1102         break;
 
  1201             break;
 
  1103     }
 
  1202         }
 
  1104 }
 
  1203     }
 
       
  1204 
  1105 
  1205 QTEST_MAIN_S60(QTmsCsTest)
 
  1106 QTEST_MAIN_S60(QTmsCsTest)
 
  1206 
  1107 
  1207 #include "qtmscstest.moc"
 
  1108 #include "qtmscstest.moc"
 
  1208 
  1109
FCL/sf/mw/mmappfw