/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QtTest/QtTest>

#include "qsysteminfo.h"

#include <QDebug>

QTM_USE_NAMESPACE

Q_DECLARE_METATYPE(QSystemInfo::Version);

Q_DECLARE_METATYPE(QSystemInfo::Feature);

Q_DECLARE_METATYPE(QSystemNetworkInfo::NetworkStatus);

Q_DECLARE_METATYPE(QSystemNetworkInfo::NetworkMode)

class tst_QSystemInfo : public QObject

{

    Q_OBJECT

private slots:

    void initTestCase();

    void tst_createTime();

    void tst_currentLanguage();

    void tst_availableLanguages();

    void tst_versions_data();

    void tst_versions();

    void tst_hasFeatures_data();

    void tst_hasFeatures();

    void tst_networkinfo_mode_data();

    void tst_networkinfo_mode();

    void tst_networkinfo_misc_data();

    void tst_networkinfo_misc();

    void tst_screeninfo_data();

    void tst_screeninfo();

    void tst_storageinfo_data();

    void tst_storageinfo();

    void tst_deviceinfo_data();

    void tst_deviceinfo();

    void tst_screensaver_data();

    void tst_screensaver();

};

void tst_QSystemInfo::initTestCase()

{

    qRegisterMetaType<QSystemInfo::Version>("QSystemInfo::Version");

    qRegisterMetaType<QSystemInfo::Feature>("QSystemInfo::Feature");

}

void tst_QSystemInfo::tst_createTime()

{

    QBENCHMARK {

        QSystemInfo si;

    }

}

void tst_QSystemInfo::tst_currentLanguage()

{

    QSystemInfo si;

    QBENCHMARK {

        QString s = si.currentLanguage();

    }

}

void tst_QSystemInfo::tst_availableLanguages()

{

    QSystemInfo si;

    QBENCHMARK {

        QStringList available = si.availableLanguages();

    }

}

void tst_QSystemInfo::tst_versions_data()

{

    QTest::addColumn<QSystemInfo::Version>("version");

    QTest::addColumn<QString>("parameter");

    QTest::newRow("Os") << QSystemInfo::Os << "";

    QTest::newRow("QtCore") << QSystemInfo::QtCore << "";

    QTest::newRow("Firmware") << QSystemInfo::Firmware << "";

}

void tst_QSystemInfo::tst_versions()

{

  QFETCH(QSystemInfo::Version, version);

  QFETCH(QString, parameter);

  QSystemInfo si;

    QBENCHMARK { 

        QString vers = si.version(version, parameter);

    }

}

void tst_QSystemInfo::tst_hasFeatures_data()

{

    QTest::addColumn<QSystemInfo::Feature>("feature");

    QTest::newRow("Bluetooth") << QSystemInfo::BluetoothFeature;

    QTest::newRow("CameraFeature") << QSystemInfo::CameraFeature;

    QTest::newRow("FmradioFeature") << QSystemInfo::FmradioFeature;

    QTest::newRow("IrFeature") << QSystemInfo::IrFeature;

    QTest::newRow("LedFeature") << QSystemInfo::LedFeature;

    QTest::newRow("MemcardFeature") << QSystemInfo::MemcardFeature;

    QTest::newRow("UsbFeature") << QSystemInfo::UsbFeature;

    QTest::newRow("VibFeature") << QSystemInfo::VibFeature;

    QTest::newRow("WlanFeature") << QSystemInfo::WlanFeature;

    QTest::newRow("SimFeature") << QSystemInfo::SimFeature;

    QTest::newRow("LocationFeature") << QSystemInfo::LocationFeature;

    QTest::newRow("VideoOutFeature") << QSystemInfo::VideoOutFeature;

    QTest::newRow("HapticsFeature") << QSystemInfo::HapticsFeature;

}

void tst_QSystemInfo::tst_hasFeatures()

{

  QFETCH(QSystemInfo::Feature, feature);

  QSystemInfo si;

    QBENCHMARK {        

        si.hasFeatureSupported(feature);

    }

}

void tst_QSystemInfo::tst_networkinfo_misc_data() {

  QTest::addColumn<QString>("feature");

  QTest::addColumn<int>("property");

  QSystemNetworkInfo obj;

  const QMetaObject* metaObject = obj.metaObject();

  QStringList methods;

  for(int i = metaObject->propertyOffset(); i < metaObject->propertyCount(); ++i) {

    QString name = QString::fromLatin1(metaObject->property(i).name());

    QTest::newRow(name.toAscii()) << name << i;    

  }

}

void tst_QSystemInfo::tst_networkinfo_misc() {

  QFETCH(QString, feature);

  QFETCH(int, property);  

  QSystemNetworkInfo obj;

  const QMetaObject* metaObject = obj.metaObject();

  QMetaProperty mprop = metaObject->property(property);

  if(mprop.isReadable()){

    QBENCHMARK {

      mprop.read(&obj);

    }

  }  

  else {

    QString s("Failed to find readable property: " + QString::fromLatin1(mprop.name()));

    QFAIL(s.toAscii());

  }

}

void tst_QSystemInfo::tst_networkinfo_mode_data()

{

  QTest::addColumn<QString>("feature");

  QTest::addColumn<QString>("name");

  QTest::addColumn<QSystemNetworkInfo::NetworkMode>("mode");

  QList<QPair<QString, QSystemNetworkInfo::NetworkMode> > modes;

  modes += qMakePair(QString("GsmMode"), QSystemNetworkInfo::GsmMode);

  modes += qMakePair(QString("CdmaMode"), QSystemNetworkInfo::CdmaMode);

  modes += qMakePair(QString("WcdmaMode"), QSystemNetworkInfo::WcdmaMode);

  modes += qMakePair(QString("WlanMode"), QSystemNetworkInfo::WlanMode);

  modes += qMakePair(QString("EthernetMode"), QSystemNetworkInfo::EthernetMode);

  modes += qMakePair(QString("BluetoothMode"), QSystemNetworkInfo::BluetoothMode);

  modes += qMakePair(QString("WimaxMode"), QSystemNetworkInfo::WimaxMode);

  QPair<QString, QSystemNetworkInfo::NetworkMode> mode;

  foreach(mode, modes){    

    QTest::newRow(QString("networkStatus-" + mode.first).toAscii()) << "networkStatus" << mode.first << mode.second;  

    QTest::newRow(QString("networkSignalStrength-" + mode.first).toAscii()) << "networkSignalStrength" << mode.first << mode.second;

    QTest::newRow(QString("macAddress-" + mode.first).toAscii()) << "macAddress" << mode.first << mode.second;

    QTest::newRow(QString("networkName-" + mode.first).toAscii()) << "networkName" << mode.first << mode.second;

    QTest::newRow(QString("interfaceForMode-" + mode.first).toAscii()) << "interfaceForMode" << mode.first << mode.second;

  }

}

void tst_QSystemInfo::tst_networkinfo_mode()

{

  QFETCH(QString, feature);

  QFETCH(QString, name);

  QFETCH(QSystemNetworkInfo::NetworkMode, mode);

  QSystemNetworkInfo ni;

  if(feature == "networkStatus"){

    QSystemNetworkInfo::NetworkStatus s = QSystemNetworkInfo::UndefinedStatus;

    QBENCHMARK {

      s = ni.networkStatus(mode);

    }

    //qDebug() << "Status: " << s;

  }

  else if(feature == "networkSignalStrength") {

    QBENCHMARK {

      ni.networkSignalStrength(mode);

    }

  }

  else if(feature == "macAddress"){

    QBENCHMARK {

      ni.macAddress(mode);

    }

  }

  else if(feature == "networkName"){

    QBENCHMARK {

      ni.networkName(mode);

    }

  }

  else if(feature == "interfaceForMode") {

    QBENCHMARK {

      ni.interfaceForMode(mode);

    }

  }

}

void tst_QSystemInfo::tst_screeninfo_data(){ 

  QTest::addColumn<QString>("feature");

  QTest::newRow("construction") << "construction";

  QTest::newRow("displayBrightness") << "displayBrightness";

  QTest::newRow("colorDepth") << "colorDepth";

}

void tst_QSystemInfo::tst_screeninfo(){

  QFETCH(QString, feature);   

  if(feature == "construction"){

    QBENCHMARK {

      QSystemDeviceInfo di2;

    }

  }

  else if(feature == "displayBrightness"){

    QBENCHMARK {

      QSystemDisplayInfo::displayBrightness(0);// what screen shoiuld we pick?

    }

  }

  else if(feature == "colorDepth"){

    QBENCHMARK {

      QSystemDisplayInfo::colorDepth(0);

    }

  }

  else {    

    QFAIL("Unkown feature");

  }  

}

void tst_QSystemInfo::tst_storageinfo_data(){

  QTest::addColumn<QString>("feature");

  QTest::addColumn<QString>("drive");

  QString d;

  QStringList drives = QSystemStorageInfo::logicalDrives();

  QString f;

  QStringList features;

  features += "totalDiskSpace";

  features += "availableDiskSpace";

  features += "typeForDrive";

  foreach(d, drives){

    foreach(f, features){

      QString s = f + "_" + d;

      QTest::newRow(s.toAscii()) << f << d;

    }

  }

}

void tst_QSystemInfo::tst_storageinfo(){

  QFETCH(QString, feature);

  QFETCH(QString, drive);

  QSystemStorageInfo si;

  if(feature == "totalDiskSpace"){

   QBENCHMARK {

     si.totalDiskSpace(drive);

   }

  }

  else if(feature == "availableDiskSpace"){

    QBENCHMARK {

      si.availableDiskSpace(drive);

    }

  }

  else if(feature == "typeForDrive"){

    QBENCHMARK {

      si.typeForDrive(drive);

    }

  }

  else {

    QFAIL("Unkown feature");

  }

}

void tst_QSystemInfo::tst_deviceinfo_data() {

  QTest::addColumn<QString>("feature");

  QTest::addColumn<int>("property");

  QSystemDeviceInfo obj;

  const QMetaObject* metaObject = obj.metaObject();

  QStringList methods;

  for(int i = metaObject->propertyOffset(); i < metaObject->propertyCount(); ++i) {

    QString name = QString::fromLatin1(metaObject->property(i).name());

    QTest::newRow(name.toAscii()) << name << i;       

  }

}

void tst_QSystemInfo::tst_deviceinfo() {

  QFETCH(QString, feature);

  QFETCH(int, property);

  QSystemDeviceInfo obj;

  const QMetaObject* metaObject = obj.metaObject();

  QMetaProperty mprop = metaObject->property(property);

  if(mprop.isReadable()){

    QBENCHMARK {

      mprop.read(&obj);

    }

  }  

}

void tst_QSystemInfo::tst_screensaver_data() {

  QTest::addColumn<QString>("feature");

  QTest::addColumn<int>("property");

  QSystemScreenSaver obj;

  const QMetaObject* metaObject = obj.metaObject();

  QStringList methods;

  for(int i = metaObject->propertyOffset(); i < metaObject->propertyCount(); ++i) {

    QString name = QString::fromLatin1(metaObject->property(i).name());

    QTest::newRow(name.toAscii()) << name << i;       

  }

}

void tst_QSystemInfo::tst_screensaver() {

  QFETCH(QString, feature);

  QFETCH(int, property);

  QSystemScreenSaver obj;

  const QMetaObject* metaObject = obj.metaObject();

  QMetaProperty mprop = metaObject->property(property);

  if(mprop.isReadable()){

    QBENCHMARK {

      mprop.read(&obj);

    }

  }  

}

QTEST_MAIN(tst_QSystemInfo)

#include "tst_qsysteminfo.moc"