/*

#include <QObject>

#include <QtTest/QtTest>

#include "qtestmains60.h"

#include <qtms.h>

#include <qtmsfactory.h>

#include <qtmscall.h>

#include <qtmsstream.h>

#include <tmsstreamobsrvr.h>

#include <qtmsformat.h>

#include <qtmspcmformat.h>

#include <qtmsamrformat.h>

#include <qtmsilbcformat.h>

#include <qtmsg711format.h>

#include <qtmsg729format.h>

#include <qtmsclientsink.h>

#include <qtmsclientsource.h>

#include <qtmsvolumeeffect.h>

#include <qtmsgaineffect.h>

#include <qtmsglobalvoleffect.h>

#include <qtmsglobalgaineffect.h>

#include <qtmsglobalrouting.h>

#include <qtmsbuffer.h>

#include <qtmsdtmf.h>

#include <qtmsringtone.h>

#include <qtmsinbandtone.h>

#include <tmsbuffer.h>

using namespace QTMS;

_LIT8(KRTBeepSequence, "\x00\x11\x0A\x0A\x08\x73\x0A\x40\x28\x0A\xF7\

\x05\xFC\x40\x64\x0A\x08\x40\x32\x0A\xF7\x06\x0B");

Q_OBJECT

private slots:

    void initTestCase();

    void CSCallSetup();

    void CreateUplink();

    void CreateDnlink();

    void CreateMicSource();

    void AddMicSourceToStream();

    void CreateModemSink();

    void AddModemSinkToStream();

    void CreateModemSource();

    void AddModemSourceToStream();

    void CreateSpeakerSink();

    void AddSpeakerSinkToStream();

    void CreateStreamVol();

    void CreateStreamGain();

    void InitUplink();

    void InitDnlink();

    void StartUplink();

    void StopUplink();

    void StartDnlink();

    void StreamVol();

    void StreamGain();

    void CreateGlobalVol();

    void CreateGlobalGain();

    void CreateRouting_data();

    void CreateRouting();

    void CreateInband_data();

    void CreateInband();

    void CreateDnlinkDtmf();

    void CreateUplinkDtmf();

    void InitRingTonePlayerFromProfiles();

    void PlayRingTone();

    void PauseRingTone();

    void MuteRingTone();

    void CloseRingTonePlayer();

    void CloseUplink();

    void CloseDownlink();

    void cleanupTestCase();

public slots:

    //From TMSStreamObserver

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

    //From TMSClientSinkObserver

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

    //From TMSGlobalRoutingObserver

    //From TMSRingToneObserver

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

    //From TMSDTMFObserver

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

    //From TMSInbandToneObserver

    void InitRingToneSequencePlayer();

    void StopDnlink();

    void GetAvailableOutput();

    void DisplayDevice(QTMSAudioOutput device);

    QTMSFactory *m_Factory;

    QTMSCall *m_Call;

    QTMSDTMF *m_Dnlnkdtmf;

    QTMSDTMF *m_Uplnkdtmf;

    QTMSStream *m_Dnlink;

    QTMSStream *m_Uplink;

    QTMSSource *m_MicSource;

    QTMSSource *m_ModemSource;

    QTMSSink *m_SpeakerSink;

    QTMSSink *m_ModemSink;

    QTMSEffect *m_Vol;

    QTMSEffect *m_Gain;

    QTMSEffect *m_GlobalVol;

    QTMSEffect *m_GlobalGain;

    QTMSGlobalRouting *m_Routing;

    QTMSInbandTone *m_InbandTonePlayer;

    QTMSRingTone *m_RingTonePlayer;

    GString* m_RTStr;

    QSignalSpy *m_UplinkSpy;

    QSignalSpy *m_DnlinkSpy;

    QSignalSpy *m_InbandSpy;

void QTmsCsTest::initTestCase()

    qDebug("Start QTms CS tests");

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

    m_Factory = NULL;

    m_Call = NULL;

    m_Dnlink = NULL;

    m_MicSource = NULL;

    m_ModemSource = NULL;

    m_SpeakerSink = NULL;

    m_ModemSink = NULL;

    m_Vol = NULL;

    m_Gain = NULL;

    m_GlobalVol = NULL;

    m_GlobalGain = NULL;

    m_Dnlnkdtmf = NULL;

    m_Uplnkdtmf = NULL;

    m_InbandTonePlayer = NULL;

    m_RingTonePlayer = NULL;

    m_UplinkSpy = NULL;

    m_DnlinkSpy = NULL;

    QTMSVer *ver(NULL);

    gint status;

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

    QVERIFY(status == QTMS_RESULT_SUCCESS);

void QTmsCsTest::cleanupTestCase()

    qDebug("End QTms tests");

    StopDnlink();

    m_Factory->DeleteSink(m_ModemSink);

    m_Factory->DeleteSink(m_SpeakerSink);

    m_Factory->DeleteDTMF(m_Dnlnkdtmf);

    m_Factory->DeleteInbandTonePlayer(m_InbandTonePlayer);

    m_Factory->DeleteRingTonePlayer(m_RingTonePlayer);

    m_Factory->DeleteEffect(m_Vol);

    m_Factory->DeleteEffect(m_Gain);

    m_Factory->DeleteEffect(m_GlobalVol);

    m_Factory->DeleteEffect(m_GlobalGain);

    m_Factory->DeleteGlobalRouting(m_Routing);

    m_Call->DeleteStream(m_Uplink);

    m_Call->DeleteStream(m_Dnlink);

    m_Factory->DeleteCall(m_Call);

    delete m_Factory;

void QTmsCsTest::CSCallSetup()

    gint status(QTMS_RESULT_SUCCESS);

        gboolean issupported(FALSE);

        m_Factory->IsCallTypeSupported(QTMS_CALL_CS, issupported);

        QVERIFY(issupported == TRUE);

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

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        QTMSCallType calltype = m_Call->GetCallType();

        QVERIFY(calltype == QTMS_CALL_CS);

    QVERIFY(status == QTMS_RESULT_SUCCESS);

void QTmsCsTest::CreateUplink()

    gint status(QTMS_RESULT_SUCCESS);

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

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        m_UplinkSpy = new QSignalSpy(m_Uplink,

        QVERIFY( m_UplinkSpy->isValid() );

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

    }

    gint status(QTMS_RESULT_SUCCESS);

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

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        m_DnlinkSpy = new QSignalSpy(m_Dnlink,

        QVERIFY( m_DnlinkSpy->isValid() );

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

    }

    QVERIFY(m_Dnlink->Start() == QTMS_RESULT_SUCCESS);

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

void QTmsCsTest::StopUplink()

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

    QTest::qWait(1000);

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

void QTmsCsTest::StopDnlink()

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

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

void QTmsCsTest::CloseUplink()

    m_Uplink->Deinit();

    QTest::qWait(1000);

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

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

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

        }

    }

void QTmsCsTest::CreateStreamVol()

    gint status(QTMS_RESULT_SUCCESS);

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

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        connect(static_cast<QTMSVolumeEffect*> (m_Vol),

        QVERIFY(status == QTMS_RESULT_SUCCESS);

    }

void QTmsCsTest::StreamVol()

    gint status(QTMS_RESULT_SUCCESS);

    guint maxvol(0);

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

        QVERIFY(status == QTMS_RESULT_SUCCESS);

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

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        QTest::qWait(1000);

        guint vol(0);

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

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        QCOMPARE(vol,maxvol);

    }

void QTmsCsTest::CreateStreamGain()

    gint status(QTMS_RESULT_SUCCESS);

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

        QVERIFY(status == QTMS_RESULT_SUCCESS);

        connect(static_cast<QTMSGainEffect*> (m_Gain),

            status = m_Uplink->AddEffect(m_Gain);

        QVERIFY(status == QTMS_RESULT_SUCCESS);

    }

void QTmsCsTest::StreamGain()

    gint status(QTMS_RESULT_SUCCESS);

        guint maxgain(0);