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: This class is test case for backupsettings and restoresettings

    15 *

    16 */

    17 

    18 #include <QtTest/QtTest>

    19 

    20 #include "fmbackupsettings.h"

    21 #include "fmrestoresettings.h"

    22 #include "fmbkupengine.h"

    23 #include <QStringList>

    24 

    25 #include <hbglobal.h>

    26 #include <QTranslator>

    27 #include <QLocale>

    28 

    29 class TestSettings: public QObject

    30 {

    31     Q_OBJECT

    32 

    33 private slots:

    34 	// init test strings those are used to verify string fetch feature of FmBackupSettings.

    35 	void initTestCase();

    36 

    37     void testTestSettingsContentAll();

    38     void testTestSettingsContentOne();

    39     void testTestSettingsContentTwo();

    40 

    41     void testContentToString();

    42     void testContentToString_data();

    43 

    44     void testSchedulingToString();

    45     void testSchedulingToString_data();

    46 

    47     void testWeekdayToString();

    48     void testWeekdayToString_data();

    49 

    50     void testFmBackupEntry();

    51 

    52     void testFmRestoreInfo();

    53     void testFmRestoreEntry();

    54 

    55     void cleanupTestCase();       // Finalize test data

    56 

    57 private:

    58     FmBackupSettings *settings;

    59 	QString mFileManagerBackupWeekdayMonday;

    60 	QString mFileManagerBackupWeekdayTuesday;

    61 	QString mFileManagerBackupWeekdayWednesday;

    62 	QString mFileManagerBackupWeekdayThursday;

    63 	QString mFileManagerBackupWeekdayFirday;

    64 	QString mFileManagerBackupWeekdaySaturday;

    65 	QString mFileManagerBackupWeekdaySunday;

    66 

    67 	QString mFileManagerBackupScheduleNever;

    68 	QString mFileManagerBackupScheduleDaily;

    69 	QString mFileManagerBackupScheduleWeekly;

    70 

    71 	QString mFileManagerBackupSettingsTitleContents;

    72 	QString mFileManagerBackupSettingsTitleScheduling;

    73 	QString mFileManagerBackupSettingsTitleWeekday;

    74 	QString mFileManagerBackupSettingsTitleTime;

    75 	QString mFileManagerBackupSettingsTitleTargetDrive;

    76 

    77 	QString mFileManagerBackupSettingsContentAll;

    78 	QString mFileManagerBackupSettingsContentSettings;

    79 	QString mFileManagerBackupSettingsContentMessages;

    80 	QString mFileManagerBackupSettingsContentContacts;

    81 	QString mFileManagerBackupSettingsContentCalendar;

    82 	QString mFileManagerBackupSettingsContentBookmarks;

    83 	QString mFileManagerBackupSettingsContentUserFiles;

    84 };

    85 

    86 void TestSettings::initTestCase()

    87 {

    88 	// install translator

    89 	QTranslator translator;

    90     QString lang = QLocale::system().name(); 

    91     QString path = "z:/resource/qt/translations/"; 

    92     translator.load( path + "filemanager_" + lang );

    93     QCoreApplication::installTranslator(&translator);

    94 

    95 	// init localized string

    96 	mFileManagerBackupWeekdayMonday = hbTrId( "Monday" );

    97 	mFileManagerBackupWeekdayTuesday = hbTrId( "Tuesday" );

    98 	mFileManagerBackupWeekdayWednesday = hbTrId( "Wednesday" );

    99 	mFileManagerBackupWeekdayThursday = hbTrId( "Thursday" );

   100 	mFileManagerBackupWeekdayFirday = hbTrId( "Friday" );

   101 	mFileManagerBackupWeekdaySaturday = hbTrId( "Saturday" );

   102 	mFileManagerBackupWeekdaySunday = hbTrId( "Sunday" );

   103 

   104 	mFileManagerBackupScheduleNever = hbTrId( "Never" );

   105 	mFileManagerBackupScheduleDaily = hbTrId( "Daily" );

   106 	mFileManagerBackupScheduleWeekly = hbTrId( "Weekly" );

   107 

   108 	mFileManagerBackupSettingsTitleContents = hbTrId( "Backup Contents" );

   109 	mFileManagerBackupSettingsTitleScheduling = hbTrId( "Backup scheduling" );

   110 	mFileManagerBackupSettingsTitleWeekday = hbTrId( "Weekday" );

   111 	mFileManagerBackupSettingsTitleTime = hbTrId( "Time" );

   112 	mFileManagerBackupSettingsTitleTargetDrive = hbTrId( "Backup destination" );

   113 

   114 	mFileManagerBackupSettingsContentAll = hbTrId( "All" );

   115 	mFileManagerBackupSettingsContentSettings = hbTrId( "Settings" );

   116 	mFileManagerBackupSettingsContentMessages = hbTrId( "Messages" );

   117 	mFileManagerBackupSettingsContentContacts = hbTrId( "Contacts" );

   118 	mFileManagerBackupSettingsContentCalendar = hbTrId( "Calendar" );

   119 	mFileManagerBackupSettingsContentBookmarks = hbTrId( "Bookmarks" );

   120 	mFileManagerBackupSettingsContentUserFiles = hbTrId( "Files" );

   121 }

   122 

   123 void TestSettings::cleanupTestCase()

   124 {

   125     QCoreApplication::processEvents();

   126 }

   127 

   128 void TestSettings::testTestSettingsContentAll()

   129 {

   130     FmBkupEngine *backupEngine = new FmBkupEngine( this );

   131     settings = new FmBackupSettings( backupEngine );

   132     QTime time = QTime::currentTime();

   133     settings->setContent(FmBackupSettings::EFileManagerBackupContentAll);

   134     settings->setScheduling(FmBackupSettings::EFileManagerBackupScheduleWeekly);

   135     settings->setWeekday(FmBackupSettings::EFileManagerBackupWeekdayMonday);

   136     settings->setTime(time);

   137     settings->setTargetDrive("C:");

   138 

   139     settings->save();

   140     delete settings;

   141     

   142 

   143     settings = new FmBackupSettings( backupEngine );

   144     settings->load();

   145 

   146     QVERIFY(settings->content() == FmBackupSettings::EFileManagerBackupContentAll);

   147     QVERIFY(settings->scheduling() == FmBackupSettings::EFileManagerBackupScheduleWeekly);

   148     QVERIFY(settings->weekday() == FmBackupSettings::EFileManagerBackupWeekdayMonday);

   149     QVERIFY( settings->time().toString() == time.toString() );

   150     QVERIFY(settings->targetDrive() == "C:");

   151 

   152     QList< FmBackupEntry* > backupEntryList = settings->backupEntryList();

   153     

   154     for( int i = 0; i< backupEntryList.count(); i++ )

   155     {

   156         FmBackupEntry* entry = backupEntryList[i];

   157         switch( entry->type() )

   158         {

   159         case FmBackupEntry::EContents:

   160             {

   161             QVERIFY( entry->title() == mFileManagerBackupSettingsTitleContents );

   162             break;

   163             }

   164         case FmBackupEntry::EScheduling:

   165             {

   166             QVERIFY( entry->title() == mFileManagerBackupSettingsTitleScheduling );

   167             break;

   168             }

   169         case FmBackupEntry::EWeekday:

   170             {

   171             QVERIFY( entry->title() == mFileManagerBackupSettingsTitleWeekday );

   172             break;

   173             }

   174         case FmBackupEntry::ETime:

   175             {

   176             QVERIFY( entry->title() == mFileManagerBackupSettingsTitleTime );

   177             break;

   178             }

   179         case FmBackupEntry::ETarget:

   180             {

   181             QVERIFY( entry->title() == mFileManagerBackupSettingsTitleTargetDrive );

   182             break;

   183             }

   184 

   185         }

   186         qDebug( entry->title().toUtf8().data() );

   187         qDebug( entry->tips().toUtf8().data() );

   188     }

   189     delete backupEngine;

   190 }

   191 

   192 

   193 void TestSettings::testTestSettingsContentOne()

   194 {

   195     FmBkupEngine *backupEngine = new FmBkupEngine( this );

   196     settings = new FmBackupSettings( backupEngine );

   197     QTime time = QTime::currentTime();

   198     settings->setContent(FmBackupSettings::EFileManagerBackupContentSettings | 

   199         FmBackupSettings::EFileManagerBackupContentMessages);

   200     settings->setScheduling(FmBackupSettings::EFileManagerBackupScheduleWeekly);

   201     settings->setWeekday(FmBackupSettings::EFileManagerBackupWeekdayWednesday);

   202     settings->setTime(time);

   203     settings->setTargetDrive("E:");

   204 

   205     settings->save();

   206     delete settings;

   207 

   208     settings = new FmBackupSettings( backupEngine );

   209     settings->load();

   210 

   211     QVERIFY(settings->content() == quint32(FmBackupSettings::EFileManagerBackupContentSettings |

   212         FmBackupSettings::EFileManagerBackupContentMessages));

   213     QVERIFY(settings->scheduling() == FmBackupSettings::EFileManagerBackupScheduleWeekly);

   214     QVERIFY(settings->weekday() == FmBackupSettings::EFileManagerBackupWeekdayWednesday);

   215     QVERIFY( settings->time().toString() == time.toString() );

   216     QVERIFY(settings->targetDrive() == "E:");

   217     delete backupEngine;

   218 }

   219 

   220 void TestSettings::testTestSettingsContentTwo()

   221 {

   222     FmBkupEngine *backupEngine = new FmBkupEngine( this );

   223     settings = new FmBackupSettings( backupEngine );

   224     QTime time = QTime::currentTime();

   225     settings->setContent(FmBackupSettings::EFileManagerBackupContentSettings | 

   226         FmBackupSettings::EFileManagerBackupContentMessages);

   227     settings->setScheduling(FmBackupSettings::EFileManagerBackupScheduleWeekly);

   228     settings->setWeekday(FmBackupSettings::EFileManagerBackupWeekdayWednesday);

   229     settings->setTime(time);

   230     settings->setTargetDrive("E:");

   231 

   232     settings->save();

   233     delete settings;

   234 

   235     settings = new FmBackupSettings( backupEngine );

   236     settings->load();

   237 

   238     QVERIFY(settings->content() == quint32( FmBackupSettings::EFileManagerBackupContentSettings |

   239         FmBackupSettings::EFileManagerBackupContentMessages ) );

   240     QVERIFY(settings->scheduling() == FmBackupSettings::EFileManagerBackupScheduleWeekly);

   241     QVERIFY(settings->weekday() == FmBackupSettings::EFileManagerBackupWeekdayWednesday);

   242     QVERIFY( settings->time().toString() == time.toString() );

   243     QVERIFY(settings->targetDrive() == "E:");

   244     delete backupEngine;

   245 }

   246 

   247 void TestSettings::testContentToString()

   248 {

   249     QFETCH(quint32, param);

   250     QFETCH(QString, value);

   251 

   252     QCOMPARE(FmBackupSettings::contentToString( param ), value);

   253 }

   254 

   255 void TestSettings::testContentToString_data()

   256 {

   257     QTest::addColumn<quint32>("param");

   258     QTest::addColumn<QString>("value");

   259 

   260     QTest::newRow("contentToString_0") << (quint32)FmBackupSettings::EFileManagerBackupContentAll << mFileManagerBackupSettingsContentAll;

   261     QTest::newRow("contentToString_1") << (quint32)FmBackupSettings::EFileManagerBackupContentSettings << mFileManagerBackupSettingsContentSettings;

   262     QTest::newRow("contentToString_2") << (quint32)FmBackupSettings::EFileManagerBackupContentMessages << mFileManagerBackupSettingsContentMessages;

   263     QTest::newRow("contentToString_3") << (quint32)FmBackupSettings::EFileManagerBackupContentContacts << mFileManagerBackupSettingsContentContacts;

   264     QTest::newRow("contentToString_4") << (quint32)FmBackupSettings::EFileManagerBackupContentCalendar << mFileManagerBackupSettingsContentCalendar;

   265     QTest::newRow("contentToString_5") << (quint32)FmBackupSettings::EFileManagerBackupContentBookmarks << mFileManagerBackupSettingsContentBookmarks;

   266     QTest::newRow("contentToString_6") << (quint32)FmBackupSettings::EFileManagerBackupContentUserFiles << mFileManagerBackupSettingsContentUserFiles;

   267 }

   268 

   269 void TestSettings::testSchedulingToString()

   270 {

   271     QFETCH(int, param);

   272     QFETCH(QString, value);

   273     FmBkupEngine *backupEngine = new FmBkupEngine( this );

   274     settings = new FmBackupSettings( backupEngine );

   275     QCOMPARE(settings->schedulingToString( (FmBackupSettings::TFileManagerBackupSchedule)param ), value);

   276 }

   277 

   278 void TestSettings::testSchedulingToString_data()

   279 {

   280     QTest::addColumn<int>("param");

   281     QTest::addColumn<QString>("value");

   282 

   283     QTest::newRow("schedulingToString_0") << (int)FmBackupSettings::EFileManagerBackupScheduleNever << mFileManagerBackupScheduleNever;

   284     QTest::newRow("schedulingToString_1") << (int)FmBackupSettings::EFileManagerBackupScheduleDaily << mFileManagerBackupScheduleDaily;

   285     QTest::newRow("schedulingToString_2") << (int)FmBackupSettings::EFileManagerBackupScheduleWeekly << mFileManagerBackupScheduleWeekly;

   286 }

   287 

   288 void TestSettings::testWeekdayToString()

   289 {

   290     QFETCH(int, param);

   291     QFETCH(QString, value);

   292 

   293     QCOMPARE(FmBackupSettings::weekdayToString( (FmBackupSettings::TFileManagerBackupWeekday)param ), value);

   294 }

   295 

   296 void TestSettings::testWeekdayToString_data()

   297 {

   298 

   299     QTest::addColumn<int>("param");

   300     QTest::addColumn<QString>("value");

   301 

   302     QTest::newRow("weekdayToString_0") << (int)FmBackupSettings::EFileManagerBackupWeekdayMonday << mFileManagerBackupWeekdayMonday;

   303     QTest::newRow("weekdayToString_1") << (int)FmBackupSettings::EFileManagerBackupWeekdayTuesday << mFileManagerBackupWeekdayTuesday;

   304     QTest::newRow("weekdayToString_2") << (int)FmBackupSettings::EFileManagerBackupWeekdayWednesday << mFileManagerBackupWeekdayWednesday;

   305     QTest::newRow("weekdayToString_3") << (int)FmBackupSettings::EFileManagerBackupWeekdayThursday << mFileManagerBackupWeekdayThursday;

   306     QTest::newRow("weekdayToString_4") << (int)FmBackupSettings::EFileManagerBackupWeekdayFriday << mFileManagerBackupWeekdayFirday;

   307     QTest::newRow("weekdayToString_5") << (int)FmBackupSettings::EFileManagerBackupWeekdaySaturday << mFileManagerBackupWeekdaySaturday;

   308     QTest::newRow("weekdayToString_6") << (int)FmBackupSettings::EFileManagerBackupWeekdaySunday << mFileManagerBackupWeekdaySunday;

   309 }

   310 

   311 

   312 void TestSettings::testFmBackupEntry()

   313 {

   314     FmBackupEntry backupEntry( "title","tips", FmBackupEntry::EContents );

   315     QVERIFY( backupEntry.title() == "title" );

   316     QVERIFY( backupEntry.tips() == "tips" );

   317     QVERIFY( backupEntry.type() == FmBackupEntry::EContents );

   318 

   319     FmBackupEntry backupEntryCopy( backupEntry );

   320     QVERIFY( backupEntryCopy.title() == "title" );

   321     QVERIFY( backupEntryCopy.tips() == "tips" );

   322     QVERIFY( backupEntryCopy.type() == FmBackupEntry::EContents );

   323 

   324 }

   325 

   326 void TestSettings::testFmRestoreInfo()

   327 {

   328     QDateTime dateTime = QDateTime::currentDateTime();

   329     FmRestoreInfo restoreInfo((quint32)FmBackupSettings::EFileManagerBackupContentSettings, dateTime, "E:" );

   330     QVERIFY( restoreInfo.content() == (quint32)FmBackupSettings::EFileManagerBackupContentSettings );

   331     QVERIFY( restoreInfo.dateTime().toString() == dateTime.toString() );

   332     QVERIFY( restoreInfo.drive() == "E:" );

   333 

   334     FmRestoreInfo restoreInfoCopy( restoreInfo );

   335     QVERIFY( restoreInfoCopy.content() == restoreInfo.content() );

   336     QVERIFY( restoreInfoCopy.dateTime().toString() == restoreInfo.dateTime().toString() );

   337     QVERIFY( restoreInfoCopy.drive() == restoreInfo.drive() );

   338 

   339     FmRestoreInfo restoreInfoNext = restoreInfo;

   340     QVERIFY( restoreInfoNext.content() == restoreInfo.content() );

   341     QVERIFY( restoreInfoNext.dateTime().toString() == restoreInfo.dateTime().toString() );

   342     QVERIFY( restoreInfoNext.drive() == restoreInfo.drive() );

   343 }

   344 

   345 void TestSettings::testFmRestoreEntry()

   346 {

   347     QDateTime dateTime = QDateTime::currentDateTime();

   348     FmRestoreInfo restoreInfo((quint32)FmBackupSettings::EFileManagerBackupContentSettings, dateTime, "E:" );

   349 

   350     FmRestoreEntry restoreEntry( "displayText", restoreInfo );

   351     QVERIFY( restoreEntry.text() == "displayText");

   352     QVERIFY( restoreEntry.restoreInfo().content() == (quint32)FmBackupSettings::EFileManagerBackupContentSettings );

   353     QVERIFY( restoreEntry.restoreInfo().dateTime().toString() == dateTime.toString() );

   354     QVERIFY( restoreEntry.restoreInfo().drive() == "E:" );

   355 }

   356 

   357 QTEST_MAIN(TestSettings)

   358 #include "unit_backuprestoresettings.moc"