/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:   TestVideoSettingsGroup class implementation
* 
*/

// INCLUDE FILES
#include <QtTest/QtTest>
#include <qdebug.h>
#include <hbapplication.h>
#include <hblineedit.h>
#include <hbinputeditorinterface.h>
#include <hbinputstandardfilters.h>
#include <MPSettEngPluginImplementationUIDs.hrh>

#include "testvideosettingsgroup.h"
#include "videosettingsaccesspointentry.h"
#include "mpsettingsmodel.h"
#include "hbdataformmodel.h"
#include "cpitemdatahelper.h"
#include "hbvalidator.h"

// trick to get access to protected/private members.
#define private public
#include "videosettingsgroup.h"
#undef private

// ---------------------------------------------------------------------------
// main
// ---------------------------------------------------------------------------
//
int main(int argc, char *argv[])
{
    HbApplication app(argc, argv);
    
    TestVideoSettingsGroup tc;
    
    char *pass[3];
    pass[0] = argv[0];
    pass[1] = "-o";
    pass[2] = "c:\\data\\testvideosettingsgroup.txt";

    return QTest::qExec(&tc, 3, pass);
}

// ---------------------------------------------------------------------------
// initTestCase
// ---------------------------------------------------------------------------
//
void TestVideoSettingsGroup::initTestCase()
{
    mItemHelper = new CpItemDataHelper;
}

// ---------------------------------------------------------------------------
// cleanupTestCase
// ---------------------------------------------------------------------------
//
void TestVideoSettingsGroup::cleanupTestCase()
{
    delete mItemHelper;
    mItemHelper = 0;
}

// ---------------------------------------------------------------------------
// init
// ---------------------------------------------------------------------------
//
void TestVideoSettingsGroup::init()
{
    CMPSettingsModel::mImplUid = TUid::Null();
    CMPSettingsModel::mConfigMode = -1;
    CMPSettingsModel::mProxyMode = 0;
    CMPSettingsModel::mHostName = QString("testhostname");
    CMPSettingsModel::mProxyPort = 4096;
    CMPSettingsModel::mMinUdpPort = 2048;
    CMPSettingsModel::mMaxUdpPort = 8080;
    CMPSettingsModel::mStoreSettingsCount = 0;
    CMPSettingsModel::mDestructorCount = 0;
    CMPSettingsModel::mApId = 5;
    HbEditorInterface::mFilter = 0;
    
    mTestObject = new VideoSettingsGroup(*mItemHelper);
}

// ---------------------------------------------------------------------------
// cleanup
// ---------------------------------------------------------------------------
//
void TestVideoSettingsGroup::cleanup()
{
    disconnect();
    delete mTestObject;
    mTestObject = 0;
}

// ---------------------------------------------------------------------------
// testSettingsConstruction
// ---------------------------------------------------------------------------
//
void TestVideoSettingsGroup::testSettingsConstruction()
{
    QVERIFY( mTestObject->mSettingsModel != 0 );
    QCOMPARE( mTestObject->mSettingsModel->mConfigMode, (int)EConfigUser);
    QVERIFY( CMPSettingsModel::mImplUid == TUid::Uid(KMPSettEngImplUidROP) );
    
    // verify also the itemShown connection to form here.
    QCOMPARE( mItemHelper->mFormConnection.signal, SIGNAL(itemShown(const QModelIndex)) );
    QVERIFY( mItemHelper->mFormConnection.receiver == mTestObject );
    QCOMPARE( mItemHelper->mFormConnection.method, SLOT(itemShown(const QModelIndex)) );
}

// ---------------------------------------------------------------------------
// testAccessPointConstruction
// ---------------------------------------------------------------------------
//
void TestVideoSettingsGroup::testAccessPointConstruction()
{
    QVERIFY( mTestObject->mAccessPointItem != 0 );
    QVERIFY( mTestObject->indexOf(static_cast<HbDataFormModelItem*>(mTestObject->mAccessPointItem)) >= 0 );
    QCOMPARE( mTestObject->mAccessPointItem->mText, hbTrId("txt_videos_dblist_access_point") );
    QCOMPARE( mTestObject->mAccessPointItem->mApId, (uint)CMPSettingsModel::mApId );
}

// ---------------------------------------------------------------------------
// testLowestUdpPortConstruction
// ---------------------------------------------------------------------------
//
void TestVideoSettingsGroup::testLowestUdpPortConstruction()
{
    QVERIFY( mTestObject->mLowestUDPPortItem != 0 );
    QVERIFY( mTestObject->indexOf(mTestObject->mLowestUDPPortItem) >= 0 );
    QCOMPARE( mTestObject->mLowestUDPPortItem->contentWidgetData(QString("maxRows")).toInt(), 1);
    QCOMPARE( mTestObject->mLowestUDPPortItem->contentWidgetData(QString("text")).toString(), 
        QString::number(CMPSettingsModel::mMinUdpPort) );
    
    ConnectionHolder connection = mItemHelper->mConnections[mTestObject->mLowestUDPPortItem];
    QCOMPARE( connection.signal, SIGNAL(editingFinished()) ); 
    QVERIFY( connection.receiver == mTestObject );
    QCOMPARE( connection.method, SLOT(lowestUdpPortEditingFinished()) );
}

// ---------------------------------------------------------------------------
// testHighestUdpPortConstruction
// ---------------------------------------------------------------------------
//
void TestVideoSettingsGroup::testHighestUdpPortConstruction()
{
    QVERIFY( mTestObject->mHighestUDPPortItem != 0 );
    QVERIFY( mTestObject->indexOf(mTestObject->mHighestUDPPortItem) >= 0 );
    QCOMPARE( mTestObject->mHighestUDPPortItem->contentWidgetData(QString("maxRows")).toInt(), 1);
    QCOMPARE( mTestObject->mHighestUDPPortItem->contentWidgetData(QString("text")).toString(), 
        QString::number(CMPSettingsModel::mMaxUdpPort) );
    
    ConnectionHolder connection = mItemHelper->mConnections[mTestObject->mHighestUDPPortItem];
    QCOMPARE( connection.signal, SIGNAL(editingFinished()) ); 
    QVERIFY( connection.receiver == mTestObject );
    QCOMPARE( connection.method, SLOT(highestUdpPortEditingFinished()) );
}

// ---------------------------------------------------------------------------
// testUseProxyConstruction
// ---------------------------------------------------------------------------
//
void TestVideoSettingsGroup::testUseProxyConstruction()
{
    QVERIFY( mTestObject->mUseProxyItem != 0 );
    QVERIFY( mTestObject->indexOf(mTestObject->mUseProxyItem) >= 0 );
    QCOMPARE( mTestObject->mUseProxyItem->contentWidgetData(QString("checked")).toBool(), 
        CMPSettingsModel::mProxyMode == 1 );
    
    // connection checking in the testItemShown.
}

// ---------------------------------------------------------------------------
// testProxyServerConstruction
// ---------------------------------------------------------------------------
//
void TestVideoSettingsGroup::testProxyServerConstruction()
{
    QVERIFY( mTestObject->mProxyServerItem != 0 );
    QVERIFY( mTestObject->indexOf(mTestObject->mProxyServerItem) >= 0 );
    QCOMPARE( mTestObject->mProxyServerItem->contentWidgetData(QString("maxRows")).toInt(), 1);
    QCOMPARE( mTestObject->mProxyServerItem->contentWidgetData(QString("text")).toString(), 
        CMPSettingsModel::mHostName );
    QCOMPARE( mTestObject->mProxyServerItem->contentWidgetData(QString("placeholderText")).toString(),
        hbTrId("txt_videos_dblist_none") );

    ConnectionHolder connection = mItemHelper->mConnections[mTestObject->mProxyServerItem];
    QCOMPARE( connection.signal, SIGNAL(editingFinished()) ); 
    QVERIFY( connection.receiver == mTestObject );
    QCOMPARE( connection.method, SLOT(proxyServerEditingFinished()) );
}

// ---------------------------------------------------------------------------
// testProxyPortConstruction
// ---------------------------------------------------------------------------
//
void TestVideoSettingsGroup::testProxyPortConstruction()
{
    QVERIFY( mTestObject->mProxyPortItem != 0 );
    QVERIFY( mTestObject->indexOf(mTestObject->mProxyPortItem) >= 0 );
    QCOMPARE( mTestObject->mProxyPortItem->contentWidgetData(QString("maxRows")).toInt(), 1);
    QCOMPARE( mTestObject->mProxyPortItem->contentWidgetData(QString("text")).toString(), 
        QString::number(CMPSettingsModel::mProxyPort) );

    ConnectionHolder connection = mItemHelper->mConnections[mTestObject->mProxyPortItem];
    QCOMPARE( connection.signal, SIGNAL(editingFinished()) ); 
    QVERIFY( connection.receiver == mTestObject );
    QCOMPARE( connection.method, SLOT(proxyPortEditingFinished()) );
}

// ---------------------------------------------------------------------------
// testDestructor
// ---------------------------------------------------------------------------
//
void TestVideoSettingsGroup::testDestructor()
{
    delete mTestObject;
    mTestObject = 0;
    QCOMPARE( CMPSettingsModel::mStoreSettingsCount, 1 );
    QCOMPARE( CMPSettingsModel::mDestructorCount, 1 );
}

// ---------------------------------------------------------------------------
// testDestructor
// ---------------------------------------------------------------------------
//
void TestVideoSettingsGroup::testGetAccessPointId()
{
    CMPSettingsModel::mApId = 4;
    
    QCOMPARE( mTestObject->getAccessPointId(), (uint)CMPSettingsModel::mApId );
}

// ---------------------------------------------------------------------------
// testDestructor
// ---------------------------------------------------------------------------
//
void TestVideoSettingsGroup::testSetAccessPointId()
{
    CMPSettingsModel::mApId = -1;
    
    uint ap = 3;
    
    mTestObject->setAccessPointId(ap);
    
    QCOMPARE( CMPSettingsModel::mApId, (int)ap );
}

// ---------------------------------------------------------------------------
// testLowestUdpPortEditingFinished
// ---------------------------------------------------------------------------
//
void TestVideoSettingsGroup::testLowestUdpPortEditingFinished()
{
    connect(this, SIGNAL(testTextSignal()),
        mTestObject, SLOT(lowestUdpPortEditingFinished()));
    
    QString highText("12345");
    mTestObject->mHighestUDPPortItem->setContentWidgetData(QString("text"), highText);
    
    QString testString("1234");
    mTestObject->mLowestUDPPortItem->setContentWidgetData(QString("text"), testString);
    
    emit testTextSignal();
    
    QCOMPARE( CMPSettingsModel::mMinUdpPort, testString.toInt() );
    
    CMPSettingsModel::mMinUdpPort = 0;
    mTestObject->mLowestUDPPortItem->setContentWidgetData(QString("text"), QString("12346"));
    
    emit testTextSignal();
    
    QCOMPARE( CMPSettingsModel::mMinUdpPort, highText.toInt() );
    
    CMPSettingsModel::mMinUdpPort = 0;
    testString = "12345";
    mTestObject->mLowestUDPPortItem->setContentWidgetData(QString("text"), testString);
    
    emit testTextSignal();
    
    QCOMPARE( CMPSettingsModel::mMinUdpPort, testString.toInt() );    
}

// ---------------------------------------------------------------------------
// testHighestUdpPortEditingFinished
// ---------------------------------------------------------------------------
//
void TestVideoSettingsGroup::testHighestUdpPortEditingFinished()
{
    connect(this, SIGNAL(testTextSignal()),
        mTestObject, SLOT(highestUdpPortEditingFinished()));
    
    QString lowText("1234");
    mTestObject->mLowestUDPPortItem->setContentWidgetData(QString("text"), lowText);
    
    QString testString("12345");
    mTestObject->mHighestUDPPortItem->setContentWidgetData(QString("text"), testString);
    
    emit testTextSignal();
    
    QCOMPARE( CMPSettingsModel::mMaxUdpPort, testString.toInt() );
    
    CMPSettingsModel::mMaxUdpPort = 0;
    mTestObject->mHighestUDPPortItem->setContentWidgetData(QString("text"), QString("1233"));
    
    emit testTextSignal();
    
    QCOMPARE( CMPSettingsModel::mMaxUdpPort, lowText.toInt() );
    
    CMPSettingsModel::mMaxUdpPort = 0;
    testString = "1234";
    mTestObject->mHighestUDPPortItem->setContentWidgetData(QString("text"), testString);
    
    emit testTextSignal();
    
    QCOMPARE( CMPSettingsModel::mMaxUdpPort, testString.toInt() );
}

// ---------------------------------------------------------------------------
// testUseProxyToggled
// ---------------------------------------------------------------------------
//
void TestVideoSettingsGroup::testUseProxyToggled()
{
    connect(this, SIGNAL(testIntSignal(int)),
        mTestObject, SLOT(useProxyToggled(int)));
    
    emit testIntSignal(Qt::Unchecked);
    
    QVERIFY( mTestObject->mProxyServerItem->isEnabled() == false );
    QVERIFY( mTestObject->mProxyPortItem->isEnabled() == false );
    QCOMPARE( CMPSettingsModel::mProxyMode, 0);
    
    emit testIntSignal(Qt::Checked);
    
    QVERIFY( mTestObject->mProxyServerItem->isEnabled() );
    QVERIFY( mTestObject->mProxyPortItem->isEnabled() );
    QCOMPARE( CMPSettingsModel::mProxyMode, 1);
}

// ---------------------------------------------------------------------------
// testProxyServerEditingFinished
// ---------------------------------------------------------------------------
//
void TestVideoSettingsGroup::testProxyServerEditingFinished()
{
    connect(this, SIGNAL(testTextSignal()),
        mTestObject, SLOT(proxyServerEditingFinished()));
    
    QString testString("testtesttest");
    mTestObject->mProxyServerItem->setContentWidgetData(QString("text"), testString);
    
    emit testTextSignal();
    QCOMPARE( CMPSettingsModel::mHostName, testString );
}

// ---------------------------------------------------------------------------
// testProxyPortEditingFinished
// ---------------------------------------------------------------------------
//
void TestVideoSettingsGroup::testProxyPortEditingFinished()
{
    connect(this, SIGNAL(testTextSignal()),
        mTestObject, SLOT(proxyPortEditingFinished()));
    
    QString testString("1234");
    mTestObject->mProxyPortItem->setContentWidgetData(QString("text"), testString);
    
    emit testTextSignal();
    QCOMPARE( CMPSettingsModel::mProxyPort, testString.toInt() );
}

// ---------------------------------------------------------------------------
// testItemShown
// ---------------------------------------------------------------------------
//
void TestVideoSettingsGroup::testItemShown()
{
    connect(this, SIGNAL(testShownSignal(const QModelIndex&)), 
        mTestObject, SLOT(itemShown(const QModelIndex&)));
    
    QModelIndex index;
    
    HbLineEdit* editor = new HbLineEdit();
    mItemHelper->mWidgetReturnValue = editor;
    
    QIntValidator* val;
    
    mItemHelper->mModelItemReturnValue = mTestObject->mLowestUDPPortItem;
    HbEditorInterface::mFilter = 0;
    emit testShownSignal(index);
    QVERIFY( HbEditorInterface::mFilter == HbDigitsOnlyFilter::instance() );
    QCOMPARE( editor->mValidator->mValidators.count(), 1 );
    val = static_cast<QIntValidator*>(editor->mValidator->mValidators.at(0));
    QCOMPARE( val->bottom(), 1024 );
    QCOMPARE( val->top(), 65535 );

    mItemHelper->mModelItemReturnValue = mTestObject->mProxyPortItem;
    HbEditorInterface::mFilter = 0;
    emit testShownSignal(index);
    QVERIFY( HbEditorInterface::mFilter == HbDigitsOnlyFilter::instance() );
    QCOMPARE( editor->mValidator->mValidators.count(), 1 );
    val = static_cast<QIntValidator*>(editor->mValidator->mValidators.at(0));
    QCOMPARE( val->bottom(), 1 );
    QCOMPARE( val->top(), 65535 );
    
    mItemHelper->mModelItemReturnValue = mTestObject->mHighestUDPPortItem;
    HbEditorInterface::mFilter = 0;
    emit testShownSignal(index);
    QVERIFY( HbEditorInterface::mFilter == HbDigitsOnlyFilter::instance() );
    QCOMPARE( editor->mValidator->mValidators.count(), 1 );
    val = static_cast<QIntValidator*>(editor->mValidator->mValidators.at(0));
    QCOMPARE( val->bottom(), 1024 );
    QCOMPARE( val->top(), 65535 );
    
    mItemHelper->mModelItemReturnValue = mTestObject->mProxyServerItem;
    HbEditorInterface::mFilter = 0;
    emit testShownSignal(index);
    QVERIFY( HbEditorInterface::mFilter == HbUrlFilter::instance() );
    
    // verify the use proxy connection:
    ConnectionHolder connection = mItemHelper->mConnections[mTestObject->mUseProxyItem];
    QCOMPARE( connection.signal, SIGNAL(stateChanged(int)) ); 
    QVERIFY( connection.receiver == mTestObject );
    QCOMPARE( connection.method, SLOT(useProxyToggled(int)) );
    
    delete editor;
}

// end of file