1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: QTMS CS test

    15 *

    16 */

    17 #include <QObject>

    18 #include <QtTest/QtTest>

    19 #include "qtestmains60.h"

    20 

    21 #include <qtms.h>

    22 #include <qtmsfactory.h>

    23 #include <qtmscall.h>

    24 #include <qtmsstream.h>

    25 #include <tmsstreamobsrvr.h>

    26 #include <qtmsformat.h>

    27 

    28 #include <qtmspcmformat.h>

    29 #include <qtmsamrformat.h>

    30 #include <qtmsilbcformat.h>

    31 #include <qtmsg711format.h>

    32 #include <qtmsg729format.h>

    33 

    34 #include <qtmsclientsink.h>

    35 #include <qtmsclientsource.h>

    36 #include <qtmsvolumeeffect.h>

    37 #include <qtmsgaineffect.h>

    38 #include <qtmsglobalvoleffect.h>

    39 #include <qtmsglobalgaineffect.h>

    40 #include <qtmsglobalrouting.h>

    41 

    42 #include <qtmsbuffer.h>

    43 #include <qtmsdtmf.h>

    44 #include <qtmsringtone.h>

    45 #include <qtmsinbandtone.h>

    46 #include <tmsbuffer.h>

    47 

    48 using namespace QTMS;

    49 

    50 _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");

    52 _LIT16(KTestFile1,   "c:\\data\\sounds\\digital\\test_8khz.wav");

    53 

    54 class QTmsCsTest : public QObject

    55     {

    56 Q_OBJECT

    57 private slots:

    58     void initTestCase();

    59     void CSCallSetup();

    60     

    61     void CreateUplink();

    62     void CreateDnlink();

    63     void CreateMicSource();

    64     void AddMicSourceToStream();

    65     void CreateModemSink();

    66     void AddModemSinkToStream();

    67     void CreateModemSource();

    68     void AddModemSourceToStream();

    69     void CreateSpeakerSink();

    70     void AddSpeakerSinkToStream();

    71     

    72     void CreateStreamVol();

    73     void CreateStreamGain();

    74 

    75     void InitUplink();

    76     void InitDnlink();

    77 

    78     void StartUplink();

    79     void StopUplink();

    80     void StartDnlink();

    81     

    82     void StreamVol();

    83     void StreamGain();

    84    // void StopDnlink();

    85  

    86     void CreateGlobalVol();

    87     void CreateGlobalGain();

    88     void CreateRouting_data();

    89     void CreateRouting();

    90     

    91     void CreateInband_data();

    92     void CreateInband();

    93     void CreateDnlinkDtmf();

    94     void CreateUplinkDtmf();

    95   

    96     void CreateRingTone();    

    97 

    98     void InitRingTonePlayerFromProfiles();

    99     void PlayRingTone();

   100     void PauseRingTone();

   101     void MuteRingTone();

   102     void StopRingTone();  

   103     void CloseRingTonePlayer();

   104     

   105     void CloseUplink();

   106     void CloseDownlink();

   107     void cleanupTestCase();

   108 public slots:

   109     //From TMSStreamObserver

   110     void TMSStreamEvent(const QTMSStream& stream, QTMSSignalEvent event);

   111     //From TMSClientSinkObserver

   112     void EffectsEvent(const QTMSEffect& tmseffect, QTMSSignalEvent event);

   113     //From TMSGlobalRoutingObserver

   114     void GlobalRoutingEvent(const QTMSGlobalRouting& routing,

   115             QTMSSignalEvent event, QTMSAudioOutput output);

   116     //From TMSRingToneObserver

   117     void RingtoneEvent(const QTMSRingTone& rt, QTMSSignalEvent event);

   118     //From TMSDTMFObserver

   119     void DTMFEvent(const QTMSDTMF& dtmf, QTMSSignalEvent event);

   120     //From TMSInbandToneObserver

   121     void InbandToneEvent(const QTMSInbandTone& inbandtone,

   122             QTMSSignalEvent event);

   123 

   124 private:    

   125     void InitRingToneSequencePlayer();

   126     void InitRingTonePlayerFromFile();    

   127     void StopDnlink();

   128     void GetAvailableOutput();

   129     void DisplayDevice(QTMSAudioOutput device);

   130     

   131 private:    

   132     QTMSFactory *m_Factory;

   133     QTMSCall *m_Call;

   134     QTMSDTMF *m_Dnlnkdtmf;

   135     QTMSDTMF *m_Uplnkdtmf;

   136     QTMSStream *m_Dnlink;

   137     QTMSStream *m_Uplink;

   138     QTMSSource *m_MicSource;

   139     QTMSSource *m_ModemSource;

   140     QTMSSink *m_SpeakerSink;

   141     QTMSSink *m_ModemSink;

   142     QTMSEffect *m_Vol;

   143     QTMSEffect *m_Gain;

   144     QTMSEffect *m_GlobalVol;

   145     QTMSEffect *m_GlobalGain;

   146     QTMSGlobalRouting *m_Routing;

   147     QTMSInbandTone *m_InbandTonePlayer;

   148     QTMSRingTone *m_RingTonePlayer;

   149     GString* m_RTStr;

   150     GString* m_TTSStr;   

   151     QSignalSpy *m_UplinkSpy;

   152     QSignalSpy *m_DnlinkSpy;

   153     QSignalSpy *m_InbandSpy;

   154     QSignalSpy *m_RoutingSpy; 

   155     OutputVector  m_Availableoutputs;

   156 

   157     };

   158 

   159 void QTmsCsTest::initTestCase()

   160     {

   161     qDebug("Start QTms CS tests");

   162     

   163     g_setenv("G_SLICE", "always-malloc", 1);

   164     m_Factory = NULL;

   165     m_Call = NULL;

   166     m_Dnlink = NULL;

   167     m_Uplink = NULL;  

   168     m_MicSource = NULL;

   169     m_ModemSource = NULL;

   170     m_SpeakerSink = NULL;

   171     m_ModemSink = NULL;

   172     m_Vol = NULL;

   173     m_Gain = NULL;

   174     m_GlobalVol = NULL;

   175     m_GlobalGain = NULL;

   176     m_Routing = NULL;  

   177     m_Dnlnkdtmf = NULL;

   178     m_Uplnkdtmf = NULL;

   179     m_InbandTonePlayer = NULL;

   180     m_RingTonePlayer = NULL;

   181     m_UplinkSpy = NULL;

   182     m_DnlinkSpy = NULL;

   183     

   184     QTMSVer *ver(NULL);

   185     gint status;

   186     status = QTMSFactory::CreateFactory(m_Factory, *ver);

   187     

   188     QVERIFY(status == QTMS_RESULT_SUCCESS);

   189     

   190     qRegisterMetaType<QTMSSignalEvent>("QTMSSignalEvent");

   191     qRegisterMetaType<QTMSAudioOutput>("QTMSAudioOutput");

   192 

   193  

   194     }

   195 

   196 void QTmsCsTest::cleanupTestCase()

   197     {

   198     qDebug("End QTms tests");

   199     

   200     StopDnlink();

   201      

   202     m_Factory->DeleteSource(m_MicSource);   

   203     m_Factory->DeleteSource(m_ModemSource);  

   204     m_Factory->DeleteSink(m_ModemSink);

   205     m_Factory->DeleteSink(m_SpeakerSink);

   206              

   207     m_Factory->DeleteDTMF(m_Dnlnkdtmf);

   208     m_Factory->DeleteInbandTonePlayer(m_InbandTonePlayer);

   209     m_Factory->DeleteRingTonePlayer(m_RingTonePlayer);

   210     

   211     m_Factory->DeleteEffect(m_Vol);

   212     m_Factory->DeleteEffect(m_Gain);

   213     m_Factory->DeleteEffect(m_GlobalVol);

   214     m_Factory->DeleteEffect(m_GlobalGain);

   215     

   216     m_Factory->DeleteGlobalRouting(m_Routing);

   217     

   218     m_Call->DeleteStream(m_Uplink);

   219     m_Call->DeleteStream(m_Dnlink);

   220         

   221     m_Factory->DeleteCall(m_Call);

   222 

   223     delete m_Factory;

   224       

   225     }

   226 

   227 void QTmsCsTest::CSCallSetup()

   228     {

   229     gint status(QTMS_RESULT_SUCCESS);

   230     if (m_Factory && !m_Call)

   231         {

   232         gboolean issupported(FALSE);

   233         m_Factory->IsCallTypeSupported(QTMS_CALL_CS, issupported);

   234         QVERIFY(issupported == TRUE);

   235         status = m_Factory->CreateCall(QTMS_CALL_CS, m_Call, 0);

   236         QVERIFY(status == QTMS_RESULT_SUCCESS);

   237         QTMSCallType calltype = m_Call->GetCallType();

   238         QVERIFY(calltype == QTMS_CALL_CS);

   239         }

   240     QVERIFY(status == QTMS_RESULT_SUCCESS);

   241     }

   242 

   243 void QTmsCsTest::CreateUplink()

   244     {

   245     gint status(QTMS_RESULT_SUCCESS);

   246 

   247     if (m_Call)

   248         {

   249         status = m_Call->CreateStream(QTMS_STREAM_UPLINK, m_Uplink);

   250         

   251         QVERIFY(status == QTMS_RESULT_SUCCESS);

   252 

   253         m_UplinkSpy = new QSignalSpy(m_Uplink,

   254                 SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));

   255 

   256         QVERIFY( m_UplinkSpy->isValid() );

   257 

   258         //QCOMPARE(m_UplinkSpy->count(), 0 );

   259 

   260         

   261         connect(m_Uplink,

   262                 SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)),

   263                 this,

   264                 SLOT(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));

   265 

   266         }

   267     }

   268 

   269  void QTmsCsTest::CreateDnlink()

   270     {

   271     gint status(QTMS_RESULT_SUCCESS);

   272 

   273     if (m_Call)

   274         {

   275         status = m_Call->CreateStream(QTMS_STREAM_DOWNLINK, m_Dnlink);

   276 

   277         QVERIFY(status == QTMS_RESULT_SUCCESS);

   278         

   279         m_DnlinkSpy = new QSignalSpy(m_Dnlink,

   280                 SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));

   281 

   282         QVERIFY( m_DnlinkSpy->isValid() );

   283 

   284         //QCOMPARE(m_DnlinkSpy->count(), 0 );

   285         

   286         connect(m_Dnlink,

   287                 SIGNAL(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)),

   288                 this,

   289                 SLOT(TMSStreamEvent(const QTMSStream&, QTMSSignalEvent)));             

   290         }

   291     }

   292  

   293  

   294  void QTmsCsTest::CreateModemSink()

   295      {

   296      gint status(QTMS_RESULT_SUCCESS);

   297 

   298      if (m_Factory && !m_ModemSink)

   299          {

   300          status = m_Factory->CreateSink(QTMS_SINK_MODEM, m_ModemSink);

   301          }

   302      QVERIFY(status == QTMS_RESULT_SUCCESS);

   303      }

   304  

   305  void QTmsCsTest::CreateModemSource()

   306      {

   307      gint status(QTMS_RESULT_SUCCESS);

   308 

   309      if (m_Factory && !m_ModemSource)

   310          {

   311          status = m_Factory->CreateSource(QTMS_SOURCE_MODEM, m_ModemSource);

   312          }

   313      QVERIFY(status == QTMS_RESULT_SUCCESS);

   314      }

   315 

   316  void QTmsCsTest::AddModemSinkToStream()

   317      {

   318      gint status(QTMS_RESULT_SUCCESS);

   319      if (m_Uplink && m_ModemSink)

   320          {

   321          status = m_Uplink->AddSink(m_ModemSink);

   322          }

   323      QVERIFY(status == QTMS_RESULT_SUCCESS);

   324      }

   325  

   326  void QTmsCsTest::AddModemSourceToStream()

   327      {

   328      gint status(QTMS_RESULT_SUCCESS);

   329      if (m_Dnlink && m_ModemSource)

   330          {

   331          status = m_Dnlink->AddSource(m_ModemSource);

   332          }

   333      QVERIFY(status == QTMS_RESULT_SUCCESS);

   334      }

   335 

   336 

   337  void QTmsCsTest::CreateMicSource()

   338      {

   339      gint status(QTMS_RESULT_SUCCESS);

   340 

   341      if (m_Factory && !m_MicSource)

   342          {

   343          status = m_Factory->CreateSource(TMS_SOURCE_MIC, m_MicSource);

   344          }

   345      QVERIFY(status == QTMS_RESULT_SUCCESS);

   346      }

   347 

   348  void QTmsCsTest::AddMicSourceToStream()

   349      {

   350      gint status(QTMS_RESULT_SUCCESS);

   351      if (m_Uplink && m_MicSource)

   352          {

   353          status = m_Uplink->AddSource(m_MicSource);

   354          }

   355      QVERIFY(status == QTMS_RESULT_SUCCESS);

   356      }

   357 

   358  void QTmsCsTest::CreateSpeakerSink()

   359      {

   360      gint status(QTMS_RESULT_SUCCESS);

   361 

   362      if (m_Factory && !m_SpeakerSink)

   363          {

   364          status = m_Factory->CreateSink(QTMS_SINK_SPEAKER, m_SpeakerSink);

   365          }

   366      QVERIFY(status == QTMS_RESULT_SUCCESS);

   367      }

   368 

   369  void QTmsCsTest::AddSpeakerSinkToStream()

   370      {

   371      gint status(QTMS_RESULT_SUCCESS);

   372      if (m_Dnlink && m_SpeakerSink)

   373          {

   374          status = m_Dnlink->AddSink(m_SpeakerSink);

   375          qDebug("QTMS speaker sink added to stream");

   376          }

   377      QVERIFY(status == QTMS_RESULT_SUCCESS);

   378      }

   379  

   380  void QTmsCsTest::InitUplink()

   381      {    

   382      QVERIFY(m_Uplink->Init() == QTMS_RESULT_SUCCESS);

   383      QTest::qWait(1000);  

   384      //QCOMPARE(m_UplinkSpy->count(), 1 );

   385      }

   386 

   387  void QTmsCsTest::InitDnlink()

   388      {

   389      QVERIFY(m_Dnlink->Init() == QTMS_RESULT_SUCCESS);

   390      QTest::qWait(1000);      

   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);

   404     QTest::qWait(1000);      

   405     //QCOMPARE(m_DnlinkSpy->count(), 2 );

   406     }

   407 void QTmsCsTest::StopUplink()

   408     {

   409     QVERIFY(m_Uplink->Stop() == QTMS_RESULT_SUCCESS);

   410     QTest::qWait(1000);

   411     //QCOMPARE(m_UplinkSpy->count(), 3 );

   412     }

   413 

   414 void QTmsCsTest::StopDnlink()

   415     {

   416     QVERIFY(m_Dnlink->Stop() == QTMS_RESULT_SUCCESS);

   417     QTest::qWait(1000);  

   418     //QCOMPARE(m_DnlinkSpy->count(), 3 );

   419     }

   420 

   421 void QTmsCsTest::CloseUplink()

   422     {

   423     m_Uplink->Deinit();

   424     QTest::qWait(1000);

   425     if (m_Uplink)

   426         {

   427         if (m_Gain)

   428             {

   429             QVERIFY(m_Uplink->RemoveEffect(m_Gain)== QTMS_RESULT_SUCCESS);

   430             }

   431         if (m_MicSource)

   432             {

   433             QVERIFY(m_Uplink->RemoveSource(m_MicSource)== QTMS_RESULT_SUCCESS);

   434             }

   435         if (m_ModemSink)

   436             {

   437             QVERIFY(m_Uplink->RemoveSink(m_ModemSink)== QTMS_RESULT_SUCCESS);

   438             }

   439         }

   440     }

   441 

   442 void QTmsCsTest::CloseDownlink()

   443     {  

   444     m_Dnlink->Deinit();

   445     QTest::qWait(1000);

   446     if (m_Dnlink)

   447         {

   448         if (m_Vol)

   449             {

   450             QVERIFY(m_Dnlink->RemoveEffect(m_Vol)== QTMS_RESULT_SUCCESS);

   451             }

   452         if (m_ModemSource)

   453             {

   454             QVERIFY(m_Dnlink->RemoveSource(m_ModemSource)== QTMS_RESULT_SUCCESS);

   455             }

   456         if (m_SpeakerSink)

   457             {

   458             QVERIFY(m_Dnlink->RemoveSink(m_SpeakerSink) == QTMS_RESULT_SUCCESS);

   459             }

   460         }

   461 

   462     }

   463 

   464 void QTmsCsTest::CreateStreamVol()

   465     {

   466     gint status(QTMS_RESULT_SUCCESS);

   467 

   468     if (m_Factory && !m_Vol)

   469         {

   470         status = m_Factory->CreateEffect(QTMS_EFFECT_VOLUME, m_Vol);

   471 

   472         QVERIFY(status == QTMS_RESULT_SUCCESS);

   473 

   474         connect(static_cast<QTMSVolumeEffect*> (m_Vol),

   475                 SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)),

   476                 this, SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));

   477         

   478         if(m_Dnlink)

   479             {

   480             status = m_Dnlink->AddEffect(m_Vol);          

   481             }

   482         QVERIFY(status == QTMS_RESULT_SUCCESS);

   483 

   484         }

   485     }

   486 

   487 void QTmsCsTest::StreamVol()

   488     {

   489     gint status(QTMS_RESULT_SUCCESS);

   490     guint maxvol(0);

   491     if (m_Vol)

   492         {

   493         status = static_cast<QTMSVolumeEffect*> (m_Vol)->GetMaxLevel(maxvol);

   494         QVERIFY(status == QTMS_RESULT_SUCCESS);

   495 

   496         status = static_cast<QTMSVolumeEffect*> (m_Vol)->SetLevel(maxvol);

   497         QVERIFY(status == QTMS_RESULT_SUCCESS);

   498         QTest::qWait(1000);

   499 

   500         guint vol(0);

   501         status = static_cast<QTMSVolumeEffect*> (m_Vol)->GetLevel(vol);

   502         QVERIFY(status == QTMS_RESULT_SUCCESS);

   503 

   504         QCOMPARE(vol,maxvol);

   505         }

   506     }

   507 

   508 void QTmsCsTest::CreateStreamGain()

   509     {

   510     gint status(QTMS_RESULT_SUCCESS);

   511 

   512     if (m_Factory && !m_Gain)

   513         {

   514         status = m_Factory->CreateEffect(QTMS_EFFECT_GAIN, m_Gain);

   515         

   516         QVERIFY(status == QTMS_RESULT_SUCCESS);

   517 

   518         connect(static_cast<QTMSGainEffect*> (m_Gain),

   519                 SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)),

   520                 this,

   521                 SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));

   522         

   523         if(m_Uplink)

   524             {

   525             status = m_Uplink->AddEffect(m_Gain);

   526             }

   527         QVERIFY(status == QTMS_RESULT_SUCCESS);

   528         }

   529     }

   530 

   531 void QTmsCsTest::StreamGain()

   532     {

   533     gint status(QTMS_RESULT_SUCCESS);

   534     if (m_Gain)

   535         {

   536         guint maxgain(0);

   537         static_cast<QTMSGainEffect*> (m_Gain)->GetMaxLevel(maxgain);

   538         QVERIFY(status == QTMS_RESULT_SUCCESS);

   539 

   540         static_cast<QTMSGainEffect*> (m_Gain)->SetLevel(maxgain);

   541         QVERIFY(status == QTMS_RESULT_SUCCESS);

   542         QTest::qWait(1000);

   543 

   544         guint gain(0);

   545         static_cast<QTMSGainEffect*> (m_Gain)->GetLevel(gain);

   546         QVERIFY(status == QTMS_RESULT_SUCCESS);

   547 

   548         QCOMPARE(gain,maxgain);

   549         }

   550 

   551     }

   552 

   553 

   554 void QTmsCsTest::CreateGlobalVol()

   555     {

   556     gint status(QTMS_RESULT_SUCCESS);

   557 

   558     if (m_Factory && !m_GlobalVol)

   559         {

   560         status = m_Factory->CreateEffect(QTMS_EFFECT_GLOBAL_VOL, m_GlobalVol);

   561 

   562         QVERIFY(status == QTMS_RESULT_SUCCESS);

   563 

   564         connect(static_cast<QTMSGlobalVolEffect*> (m_GlobalVol),

   565                 SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)),

   566                 this, SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));

   567 

   568         guint maxvol(0);

   569         status = static_cast<QTMSGlobalVolEffect*>(m_GlobalVol)->GetMaxLevel(

   570                 maxvol);

   571         QVERIFY(status == QTMS_RESULT_SUCCESS);

   572 

   573         status = static_cast<QTMSGlobalVolEffect*>(m_GlobalVol)->SetLevel(

   574                 maxvol);

   575         QVERIFY(status == QTMS_RESULT_SUCCESS);

   576         QTest::qWait(1000);

   577 

   578         guint vol(0);

   579         status = static_cast<QTMSGlobalVolEffect*> (m_GlobalVol)->GetLevel(vol);

   580         QVERIFY(status == QTMS_RESULT_SUCCESS);

   581 

   582         QCOMPARE(vol,maxvol);

   583 

   584         }

   585     }

   586 

   587 

   588 void QTmsCsTest::CreateGlobalGain()

   589     {

   590     gint status(QTMS_RESULT_SUCCESS);

   591 

   592     if (m_Factory && !m_GlobalGain)

   593         {

   594         status = m_Factory->CreateEffect(QTMS_EFFECT_GLOBAL_GAIN, m_GlobalGain);

   595         

   596         QVERIFY(status == QTMS_RESULT_SUCCESS);

   597 

   598         connect(static_cast<QTMSGlobalGainEffect*> (m_GlobalGain),

   599                 SIGNAL(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)),

   600                 this,

   601                 SLOT(EffectsEvent(const QTMSEffect&,QTMSSignalEvent)));

   602         

   603         guint maxgain(0);

   604         static_cast<QTMSGlobalGainEffect*>(m_GlobalGain)->GetMaxLevel(maxgain);

   605         QVERIFY(status == QTMS_RESULT_SUCCESS);

   606         

   607         static_cast<QTMSGlobalGainEffect*>(m_GlobalGain)->SetLevel(maxgain);

   608         QVERIFY(status == QTMS_RESULT_SUCCESS);

   609         QTest::qWait(1000);

   610         

   611         guint gain(0);

   612         static_cast<QTMSGlobalGainEffect*>(m_GlobalGain)->GetLevel(gain);

   613         QVERIFY(status == QTMS_RESULT_SUCCESS);

   614         

   615         QCOMPARE(gain,maxgain);

   616   

   617         }

   618     }

   619 

   620 void QTmsCsTest::CreateRouting_data()

   621     {

   622     gint status;

   623     if (m_Factory && !m_Routing)

   624         {

   625         status = m_Factory->CreateGlobalRouting(m_Routing);

   626         QVERIFY(status == QTMS_RESULT_SUCCESS);

   627 

   628         m_RoutingSpy = new QSignalSpy(m_Routing,

   629                       SIGNAL(GlobalRoutingEvent(const QTMSGlobalRouting&,

   630                               QTMSSignalEvent,

   631                               QTMSAudioOutput)));

   632 

   633         QVERIFY( m_RoutingSpy->isValid() );

   634 

   635        // QCOMPARE(m_RoutingSpy->count(), 0 );

   636         connect(m_Routing,

   637                 SIGNAL(GlobalRoutingEvent(const QTMSGlobalRouting&,

   638                         QTMSSignalEvent,QTMSAudioOutput)),

   639                 this,

   640                 SLOT(GlobalRoutingEvent(const QTMSGlobalRouting&,

   641                         QTMSSignalEvent,QTMSAudioOutput)));

   642         }

   643 

   644     //Populate data and test based on available output

   645     GetAvailableOutput();

   646     }

   647 

   648 void QTmsCsTest::CreateRouting()

   649     {

   650     gint status(QTMS_RESULT_SUCCESS);

   651     

   652     QFETCH(QTMSAudioOutput, routing);

   653     

   654     if(m_Routing)

   655         {

   656         status = m_Routing->SetOutput(routing);

   657         QVERIFY(status == QTMS_RESULT_SUCCESS);

   658 #ifndef __WINSCW__

   659         QTest::qWait(1000);            

   660       //  QCOMPARE(m_RoutingSpy->count(), 1 );

   661 #endif

   662         QTMSAudioOutput current;     

   663         status = m_Routing->GetOutput(current);

   664 

   665         QVERIFY(status == QTMS_RESULT_SUCCESS);

   666         QCOMPARE(routing,current);

   667         

   668         QTMSAudioOutput previous;

   669         status = m_Routing->GetPreviousOutput(previous);

   670         QVERIFY(status == QTMS_RESULT_SUCCESS);

   671         qDebug("Previous routing:");

   672         DisplayDevice(previous);

   673         } 

   674     }

   675 

   676 void QTmsCsTest::GetAvailableOutput()

   677     {

   678     gint status(QTMS_RESULT_SUCCESS);

   679 

   680     if (m_Routing)

   681         {

   682         status = m_Routing->GetAvailableOutputs(m_Availableoutputs);

   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     {

   698     QTest::addColumn<QTMSAudioOutput>("routing");

   699     

   700     switch (device)

   701         {

   702         case QTMS_AUDIO_OUTPUT_NONE:

   703             {

   704             qDebug("none");

   705             QTest::newRow("None")<<QTMS_AUDIO_OUTPUT_NONE;

   706             }

   707             break;

   708         case QTMS_AUDIO_OUTPUT_PUBLIC:

   709             {

   710             qDebug("Public");

   711             QTest::newRow("Public")<<QTMS_AUDIO_OUTPUT_PUBLIC;

   712             }

   713             break;

   714         case QTMS_AUDIO_OUTPUT_PRIVATE:

   715             {

   716             qDebug("Private");

   717             QTest::newRow("Private")<<QTMS_AUDIO_OUTPUT_PRIVATE;

   718             }

   719             break;

   720         case QTMS_AUDIO_OUTPUT_HANDSET:

   721             {

   722             qDebug("Handset");

   723             QTest::newRow("Handset")<<QTMS_AUDIO_OUTPUT_HANDSET;

   724             }

   725             break;

   726         case QTMS_AUDIO_OUTPUT_LOUDSPEAKER:

   727             {

   728             qDebug("Loudspeaker");

   729             QTest::newRow("Loud speaker")<< QTMS_AUDIO_OUTPUT_LOUDSPEAKER;

   730             }

   731             break;

   732         case QTMS_AUDIO_OUTPUT_WIRED_ACCESSORY:

   733             {

   734             qDebug("Wired accessory");

   735             QTest::newRow("Wired accessory")<<QTMS_AUDIO_OUTPUT_WIRED_ACCESSORY;

   736             }

   737             break;

   738         case QTMS_AUDIO_OUTPUT_ACCESSORY:

   739             {

   740             qDebug("Accessory");

   741             QTest::newRow("Accessory")<< QTMS_AUDIO_OUTPUT_ACCESSORY;

   742             }

   743             break;

   744         case QTMS_AUDIO_OUTPUT_ETTY:

   745             {

   746             qDebug("TTY");

   747             QTest::newRow("ETTY")<< QTMS_AUDIO_OUTPUT_ETTY;

   748             }

   749             break;

   750         default:

   751             break;

   752         }

   753     }

   754 

   755 void QTmsCsTest::CreateDnlinkDtmf()

   756     {

   757     gint status(QTMS_RESULT_SUCCESS);

   758     GString* dtmfstring(NULL);

   759 

   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;

  1037         default:

  1038             break;

  1039         }

  1040     }

  1041 

  1042 

  1043 void QTmsCsTest::GlobalRoutingEvent(const QTMSGlobalRouting& /*routing*/,

  1044         QTMSSignalEvent event, QTMSAudioOutput /*output*/)

  1045     {

  1046     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);

  1047     switch (event.type)

  1048         {

  1049         case TMS_EVENT_ROUTING_AVAIL_OUTPUTS_CHANGED:

  1050             qDebug("Available outputs changed");

  1051             break;

  1052         case TMS_EVENT_ROUTING_OUTPUT_CHANGED:

  1053             qDebug("output changed");

  1054             break;

  1055         case TMS_EVENT_ROUTING_SET_OUTPUT_COMPLETE:

  1056             qDebug("set output complete");

  1057             break;

  1058         default:

  1059             break;

  1060         }

  1061     

  1062     }

  1063 

  1064 void QTmsCsTest::TMSStreamEvent(const QTMSStream& stream,

  1065         QTMSSignalEvent event)

  1066     {

  1067     

  1068     QVERIFY(event.reason == QTMS_RESULT_SUCCESS);

  1069     

  1070     gint streamId;

  1071     streamId = const_cast<QTMSStream&> (stream).GetStreamId();

  1072     qDebug("StreamID %d",streamId);

  1073     gint state;

  1074     state = const_cast<QTMSStream&> (stream).GetState();

  1075     QVERIFY(state == event.curr_state);

  1076 

  1077     switch (const_cast<QTMSStream&> (stream).GetStreamType())

  1078         {

  1079         case QTMS_STREAM_UPLINK:

  1080             {

  1081             switch (event.type)

  1082                 {

  1083                 case QTMS_EVENT_STREAM_STATE_CHANGED:

  1084                     {

  1085                     switch (event.curr_state)

  1086                         {

  1087                         case QTMS_STREAM_INITIALIZED:

  1088                             {

  1089                             qDebug("Uplink initialized ");

  1090                             break;

  1091                             }

  1092                         case QTMS_STREAM_UNINITIALIZED:

  1093                             qDebug("Uplink uninitialized ");

  1094                             break;

  1095                         case QTMS_STREAM_PAUSED:

  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;

  1110             }

  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;