1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

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

     6 **

     7 ** This file is part of the test suite of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 

    43 //#define QT_TST_QAPP_DEBUG

    44 #include <qdebug.h>

    45 

    46 #include <QtTest/QtTest>

    47 

    48 #include "qabstracteventdispatcher.h"

    49 #include <QtGui>

    50 

    51 #include "private/qapplication_p.h"

    52 #include "private/qstylesheetstyle_p.h"

    53 #ifdef Q_OS_WINCE

    54 #include <windows.h>

    55 #endif

    56 #ifdef Q_OS_SYMBIAN

    57 #include <aknenv.h>

    58 #endif

    59 

    60 //TESTED_CLASS=

    61 //TESTED_FILES=

    62 

    63 #if defined(Q_OS_SYMBIAN)

    64 // In Symbian, the PluginsPath doesn't specify the only absolute path; just the dir that can be found on any drive

    65 /*static void addExpectedSymbianPluginsPath(QStringList& expected)

    66 {

    67     QString installPathPlugins = QDir::fromNativeSeparators(QLibraryInfo::location(QLibraryInfo::PluginsPath));

    68     QFileInfoList driveList = QDir::drives();

    69     QListIterator<QFileInfo> iter(driveList);

    70     while (iter.hasNext()) {

    71         QFileInfo testFi(iter.next().canonicalPath().append(installPathPlugins));

    72         if (testFi.exists())

    73             expected << testFi.canonicalFilePath();

    74     }

    75 }

    76 */

    77 #endif

    78 

    79 class tst_QApplication : public QObject

    80 {

    81 Q_OBJECT

    82 

    83 public:

    84     tst_QApplication();

    85     virtual ~tst_QApplication();

    86 

    87 public slots:

    88     void init();

    89     void cleanup();

    90 private slots:

    91     /*void sendEventsOnProcessEvents(); // this must be the first test

    92     void getSetCheck();

    93     void staticSetup();

    94 

    95     void alert();

    96 

    97     void multiple_data();

    98     void multiple();

    99 

   100     void nonGui();

   101 

   102     void setFont_data();

   103     void setFont();

   104 

   105     void args_data();

   106     void args();

   107 

   108     void lastWindowClosed();

   109     void quitOnLastWindowClosed();

   110     void testDeleteLater();

   111     void testDeleteLaterProcessEvents();

   112 

   113     void libraryPaths();

   114     void libraryPaths_qt_plugin_path();

   115     void libraryPaths_qt_plugin_path_2();

   116 

   117     void sendPostedEvents();

   118 

   119     void thread();

   120     void desktopSettingsAware();*/

   121 

   122     void setActiveWindow();

   123 

   124     /*void focusChanged();

   125     void focusOut();

   126 

   127     void execAfterExit();

   128 

   129     void wheelScrollLines();

   130 

   131     void task109149();

   132 

   133     void style();

   134 

   135     void allWidgets();

   136     void topLevelWidgets();

   137 

   138     void setAttribute();

   139 

   140     void windowsCommandLine_data();

   141     void windowsCommandLine();

   142 

   143     void touchEventPropagation();

   144 

   145     void symbianNoApplicationPanes();

   146 

   147     void symbianNeedForTraps();

   148     void symbianLeaveThroughMain();*/

   149 };

   150 

   151 /*class EventSpy : public QObject

   152 {

   153    Q_OBJECT

   154 

   155 public:

   156     QList<int> recordedEvents;

   157     bool eventFilter(QObject *, QEvent *event)

   158     {

   159         recordedEvents.append(event->type());

   160         return false;

   161     }

   162 };

   163 */

   164 

   165 /*

   166 void tst_QApplication::sendEventsOnProcessEvents()

   167 {

   168     int argc = 0;

   169     QApplication app(argc, 0, QApplication::GuiServer);

   170 

   171     EventSpy spy;

   172     app.installEventFilter(&spy);

   173 

   174     QCoreApplication::postEvent(&app,  new QEvent(QEvent::Type(QEvent::User + 1)));

   175     QCoreApplication::processEvents();

   176     QVERIFY(spy.recordedEvents.contains(QEvent::User + 1));

   177 }

   178 

   179 class MyInputContext : public QInputContext

   180 {

   181 public:

   182     MyInputContext() : QInputContext() {}

   183     QString identifierName() { return QString("NoName"); }

   184     QString language() { return QString("NoLanguage"); }

   185     void reset() {}

   186     bool isComposing() const { return false; }

   187 };

   188 

   189 // Testing get/set functions

   190 void tst_QApplication::getSetCheck()

   191 {

   192     int argc = 0;

   193     QApplication obj1(argc, 0, QApplication::GuiServer);

   194     // QInputContext * QApplication::inputContext()

   195     // void QApplication::setInputContext(QInputContext *)

   196     MyInputContext *var1 = new MyInputContext;

   197     obj1.setInputContext(var1);

   198     QCOMPARE((QInputContext *)var1, obj1.inputContext());

   199     QTest::ignoreMessage(QtWarningMsg, "QApplication::setInputContext: called with 0 input context");

   200     obj1.setInputContext((QInputContext *)0);

   201     QCOMPARE((QInputContext *)var1, obj1.inputContext());

   202     // delete var1; // No delete, since QApplication takes ownership

   203 }

   204 

   205 class CloseEventTestWindow : public QWidget

   206 {

   207 public:

   208     CloseEventTestWindow(QWidget *parent = 0)

   209         : QWidget(parent)

   210     {

   211     }

   212 

   213     void closeEvent(QCloseEvent *event)

   214     {

   215         QWidget dialog;

   216         dialog.show();

   217         dialog.close();

   218 

   219         hide();

   220         event->ignore();

   221     }

   222 };

   223 */

   224 

   225 static  char *argv0;

   226 

   227 tst_QApplication::tst_QApplication()

   228 {

   229 #ifdef Q_OS_WINCE

   230     // Clean up environment previously to launching test

   231     qputenv("QT_PLUGIN_PATH", QByteArray());

   232 #endif

   233 }

   234 

   235 tst_QApplication::~tst_QApplication()

   236 {

   237 

   238 }

   239 

   240 void tst_QApplication::init()

   241 {

   242 // TODO: Add initialization code here.

   243 // This will be executed immediately before each test is run.

   244 }

   245 

   246 void tst_QApplication::cleanup()

   247 {

   248 // TODO: Add cleanup code here.

   249 // This will be executed immediately after each test is run.

   250 }

   251 

   252 /*

   253 void tst_QApplication::staticSetup()

   254 {

   255     QVERIFY(!qApp);

   256 

   257     QStyle *style = QStyleFactory::create(QLatin1String("Windows"));

   258     QVERIFY(style);

   259     QApplication::setStyle(style);

   260 

   261     QPalette pal;

   262     QApplication::setPalette(pal);

   263 

   264     //QFont font;

   265     //QApplication::setFont(font);

   266 

   267     int argc = 0;

   268     QApplication app(argc, 0, QApplication::GuiServer);

   269 }

   270 

   271 

   272 // QApp subclass that exits the event loop after 150ms

   273 class TestApplication : public QApplication

   274 {

   275 public:

   276     TestApplication( int &argc, char **argv )

   277 	: QApplication( argc, argv, QApplication::GuiServer )

   278     {

   279 	startTimer( 150 );

   280     }

   281 

   282     void timerEvent( QTimerEvent * )

   283     {

   284         quit();

   285     }

   286 };

   287 

   288 void tst_QApplication::alert()

   289 {

   290     int argc = 0;

   291     QApplication app(argc, 0, QApplication::GuiServer);

   292     app.alert(0, 0);

   293 

   294     QWidget widget;

   295     QWidget widget2;

   296     app.alert(&widget, 100);

   297     widget.show();

   298     widget2.show();

   299 #ifdef Q_WS_X11

   300     qt_x11_wait_for_window_manager(&widget);

   301     qt_x11_wait_for_window_manager(&widget2);

   302 #endif

   303     QTest::qWait(100);

   304     app.alert(&widget, -1);

   305     app.alert(&widget, 250);

   306     widget2.activateWindow();

   307     QApplication::setActiveWindow(&widget2);

   308     app.alert(&widget, 0);

   309     widget.activateWindow();

   310     QApplication::setActiveWindow(&widget);

   311     app.alert(&widget, 200);

   312     app.syncX();

   313 }

   314 

   315 void tst_QApplication::multiple_data()

   316 {

   317     QTest::addColumn<QStringList>("features");

   318 

   319     // return a list of things to try

   320     QTest::newRow( "data0" ) << QStringList( "" );

   321     QTest::newRow( "data1" ) << QStringList( "QFont" );

   322     QTest::newRow( "data2" ) << QStringList( "QPixmap" );

   323     QTest::newRow( "data3" ) << QStringList( "QWidget" );

   324 }

   325 

   326 void tst_QApplication::multiple()

   327 {

   328     QFETCH(QStringList,features);

   329 

   330     int i = 0;

   331     int argc = 0;

   332     while ( i++ < 5 ) {

   333 	TestApplication app( argc, 0 );

   334 

   335 	if ( features.contains( "QFont" ) ) {

   336 	    // create font and force loading

   337 	    QFont font( "Arial", 12 );

   338 	    QFontInfo finfo( font );

   339 	    finfo.exactMatch();

   340 	}

   341 	if ( features.contains( "QPixmap" ) ) {

   342 	    QPixmap pix( 100, 100 );

   343 	    pix.fill( Qt::black );

   344 	}

   345 	if ( features.contains( "QWidget" ) ) {

   346 	    QWidget widget;

   347 	}

   348 

   349 	QVERIFY(!app.exec());

   350     }

   351 }

   352 

   353 void tst_QApplication::nonGui()

   354 {

   355 #ifdef Q_OS_HPUX

   356     // ### This is only to allow us to generate a test report for now.

   357     QSKIP("This test shuts down the window manager on HP-UX.", SkipAll);

   358 #endif

   359 

   360     int argc = 0;

   361     QApplication app(argc, 0, false);

   362     QCOMPARE(qApp, &app);

   363 }

   364 

   365 void tst_QApplication::setFont_data()

   366 {

   367     QTest::addColumn<QString>("family");

   368     QTest::addColumn<int>("pointsize");

   369     QTest::addColumn<bool>("beforeAppConstructor");

   370 

   371     int argc = 0;

   372     QApplication app(argc, 0, QApplication::GuiServer); // Needed for QFontDatabase

   373 

   374     int cnt = 0;

   375     QFontDatabase fdb;

   376     QStringList families = fdb.families();

   377     for (QStringList::const_iterator itr = families.begin();

   378 	 itr != families.end();

   379 	 ++itr) {

   380 	if (cnt < 3) {

   381 	    QString family = *itr;

   382 	    QStringList styles = fdb.styles(family);

   383 	    if (styles.size() > 0) {

   384 		QString style = styles.first();

   385 		QList<int> sizes = fdb.pointSizes(family, style);

   386 		if (!sizes.size())

   387 		    sizes = fdb.standardSizes();

   388 		if (sizes.size() > 0) {

   389 		    QTest::newRow(QString("data%1a").arg(cnt).toLatin1().constData())

   390 			<< family

   391 			<< sizes.first()

   392                         << false;

   393 		    QTest::newRow(QString("data%1b").arg(cnt).toLatin1().constData())

   394 			<< family

   395 			<< sizes.first()

   396                         << true;

   397                 }

   398 	    }

   399 	}

   400 	++cnt;

   401     }

   402 

   403     QTest::newRow("nonexistingfont") << "nosuchfont_probably_quiteunlikely"

   404         << 0 << false;

   405     QTest::newRow("nonexistingfont") << "nosuchfont_probably_quiteunlikely"

   406         << 0 << true;

   407 

   408     QTest::newRow("largescaleable") << "smoothtimes" << 100 << false;

   409     QTest::newRow("largescaleable") << "smoothtimes" << 100 << true;

   410 

   411     QTest::newRow("largeunscaleale") << "helvetica" << 100 << false;

   412     QTest::newRow("largeunscaleale") << "helvetica" << 100 << true;

   413 }

   414 

   415 void tst_QApplication::setFont()

   416 {

   417     QFETCH( QString, family );

   418     QFETCH( int, pointsize );

   419     QFETCH( bool, beforeAppConstructor );

   420 

   421     QFont font( family, pointsize );

   422     if (beforeAppConstructor) {

   423         QApplication::setFont( font );

   424         QCOMPARE(QApplication::font(), font);

   425     }

   426 

   427     int argc = 0;

   428     QApplication app( argc, 0, QApplication::GuiServer );

   429     if (!beforeAppConstructor)

   430         QApplication::setFont( font );

   431 

   432     QCOMPARE( app.font(), font );

   433 }

   434 

   435 void tst_QApplication::args_data()

   436 {

   437     QTest::addColumn<int>("argc_in");

   438     QTest::addColumn<QString>("args_in");

   439     QTest::addColumn<int>("argc_out");

   440     QTest::addColumn<QString>("args_out");

   441 

   442     QTest::newRow( "App name" ) << 1 << "/usr/bin/appname" << 1 << "/usr/bin/appname";

   443     QTest::newRow( "No arguments" ) << 0 << QString() << 0 << QString();

   444     QTest::newRow( "App name, style" ) << 3 << "/usr/bin/appname -style motif" << 1 << "/usr/bin/appname";

   445     QTest::newRow( "App name, style, arbitrary, reverse" ) << 5 << "/usr/bin/appname -style motif -arbitrary -reverse"

   446 							<< 2 << "/usr/bin/appname -arbitrary";

   447 }

   448 

   449 void tst_QApplication::task109149()

   450 {

   451     int argc = 0;

   452     QApplication app(argc, 0, QApplication::GuiServer);

   453     QApplication::setFont(QFont("helvetica", 100));

   454 

   455     QWidget w;

   456     w.setWindowTitle("hello");

   457     w.show();

   458 

   459     app.processEvents();

   460 }

   461 

   462 static char ** QString2cstrings( const QString &args )

   463 {

   464     static QList<QByteArray> cache;

   465 

   466     int i;

   467     char **argarray = 0;

   468     QStringList list = args.split(' ');;

   469     argarray = new char*[list.count()+1];

   470 

   471     for (i = 0; i < (int)list.count(); ++i ) {

   472         QByteArray l1 = list[i].toLatin1();

   473         argarray[i] = l1.data();

   474         cache.append(l1);

   475     }

   476     argarray[i] = 0;

   477 

   478     return argarray;

   479 }

   480 

   481 static QString cstrings2QString( char **args )

   482 {

   483     QString string;

   484     if ( !args )

   485 	return string;

   486 

   487     int i = 0;

   488     while ( args[i] ) {

   489 	string += args[i];

   490 	if ( args[i+1] )

   491 	    string += " ";

   492 	++i;

   493     }

   494     return string;

   495 }

   496 

   497 void tst_QApplication::args()

   498 {

   499     QFETCH( int, argc_in );

   500     QFETCH( QString, args_in );

   501     QFETCH( int, argc_out );

   502     QFETCH( QString, args_out );

   503 

   504     char **argv = QString2cstrings( args_in );

   505 

   506     QApplication app( argc_in, argv, QApplication::GuiServer );

   507     QString argv_out = cstrings2QString(argv);

   508 

   509     QCOMPARE( argc_in, argc_out );

   510     QCOMPARE( argv_out, args_out );

   511 

   512     delete [] argv;

   513 }

   514 

   515 class CloseWidget : public QWidget

   516 {

   517     Q_OBJECT

   518 public:

   519     CloseWidget()

   520     {

   521         startTimer(500);

   522     }

   523 

   524 protected:

   525     void timerEvent(QTimerEvent *)

   526     {

   527         close();

   528     }

   529 

   530 };

   531 

   532 void tst_QApplication::lastWindowClosed()

   533 {

   534     int argc = 0;

   535     QApplication app(argc, 0, QApplication::GuiServer);

   536 

   537     QSignalSpy spy(&app, SIGNAL(lastWindowClosed()));

   538 

   539     QPointer<QDialog> dialog = new QDialog;

   540     QVERIFY(dialog->testAttribute(Qt::WA_QuitOnClose));

   541     QTimer::singleShot(1000, dialog, SLOT(accept()));

   542     dialog->exec();

   543     QVERIFY(dialog);

   544     QCOMPARE(spy.count(), 0);

   545 

   546     QPointer<CloseWidget>widget = new CloseWidget;

   547     QVERIFY(widget->testAttribute(Qt::WA_QuitOnClose));

   548     QObject::connect(&app, SIGNAL(lastWindowClosed()), widget, SLOT(deleteLater()));

   549     app.exec();

   550     QVERIFY(!widget);

   551     QCOMPARE(spy.count(), 1);

   552     spy.clear();

   553 

   554 #if 0

   555     // everything is closed, so doing this should not emit lastWindowClosed() again

   556     QMetaObject::invokeMethod(dialog, "close", Qt::QueuedConnection);

   557     QTimer::singleShot(1000, &app, SLOT(quit()));

   558     app.exec();

   559     QCOMPARE(spy.count(), 0);

   560 #endif

   561 

   562     delete dialog;

   563 

   564     // show 3 windows, close them, should only get lastWindowClosed once

   565     QWidget w1;

   566     QWidget w2;

   567     QWidget w3;

   568     w1.show();

   569     w2.show();

   570     w3.show();

   571 

   572     QTimer::singleShot(1000, &app, SLOT(closeAllWindows()));

   573     app.exec();

   574     QCOMPARE(spy.count(), 1);

   575 }

   576 

   577 class QuitOnLastWindowClosedDialog : public QDialog

   578 {

   579     Q_OBJECT

   580 public:

   581     QPushButton *okButton;

   582 

   583     QuitOnLastWindowClosedDialog()

   584     {

   585         QHBoxLayout *hbox = new QHBoxLayout(this);

   586         okButton = new QPushButton("&ok", this);

   587 

   588         hbox->addWidget(okButton);

   589         connect(okButton, SIGNAL(clicked()), this, SLOT(accept()));

   590         connect(okButton, SIGNAL(clicked()), this, SLOT(ok_clicked()));

   591     }

   592 

   593 public slots:

   594     void ok_clicked()

   595     {

   596         QDialog other;

   597 

   598         QTimer timer;

   599         connect(&timer, SIGNAL(timeout()), &other, SLOT(accept()));

   600         QSignalSpy spy(&timer, SIGNAL(timeout()));

   601         QSignalSpy appSpy(qApp, SIGNAL(lastWindowClosed()));

   602 

   603         timer.start(1000);

   604         other.exec();

   605 

   606         // verify that the eventloop ran and let the timer fire

   607         QCOMPARE(spy.count(), 1);

   608         QCOMPARE(appSpy.count(), 1);

   609     }

   610 };

   611 

   612 class QuitOnLastWindowClosedWindow : public QWidget

   613 {

   614     Q_OBJECT

   615 

   616 public:

   617     QuitOnLastWindowClosedWindow()

   618     { }

   619 

   620 public slots:

   621     void execDialogThenShow()

   622     {

   623         QDialog dialog;

   624         QTimer timer1;

   625         connect(&timer1, SIGNAL(timeout()), &dialog, SLOT(accept()));

   626         QSignalSpy spy1(&timer1, SIGNAL(timeout()));

   627         timer1.setSingleShot(true);

   628         timer1.start(1000);

   629         dialog.exec();

   630         QCOMPARE(spy1.count(), 1);

   631 

   632         show();

   633     }

   634 };

   635 

   636 void tst_QApplication::quitOnLastWindowClosed()

   637 {

   638     {

   639         int argc = 0;

   640         QApplication app(argc, 0, QApplication::GuiServer);

   641 

   642         QuitOnLastWindowClosedDialog d;

   643         d.show();

   644         QTimer::singleShot(1000, d.okButton, SLOT(animateClick()));

   645 

   646         QSignalSpy appSpy(&app, SIGNAL(lastWindowClosed()));

   647         app.exec();

   648 

   649         // lastWindowClosed() signal should only be sent after the last dialog is closed

   650         QCOMPARE(appSpy.count(), 2);

   651     }

   652     {

   653         int argc = 0;

   654         QApplication app(argc, 0, QApplication::GuiServer);

   655         QSignalSpy appSpy(&app, SIGNAL(lastWindowClosed()));

   656 

   657         QDialog dialog;

   658         QTimer timer1;

   659         connect(&timer1, SIGNAL(timeout()), &dialog, SLOT(accept()));

   660         QSignalSpy spy1(&timer1, SIGNAL(timeout()));

   661         timer1.setSingleShot(true);

   662         timer1.start(1000);

   663         dialog.exec();

   664         QCOMPARE(spy1.count(), 1);

   665         QCOMPARE(appSpy.count(), 0);

   666 

   667         QTimer timer2;

   668         connect(&timer2, SIGNAL(timeout()), &app, SLOT(quit()));

   669         QSignalSpy spy2(&timer2, SIGNAL(timeout()));

   670         timer2.setSingleShot(true);

   671         timer2.start(1000);

   672         int returnValue = app.exec();

   673         QCOMPARE(returnValue, 0);

   674         QCOMPARE(spy2.count(), 1);

   675         QCOMPARE(appSpy.count(), 0);

   676     }

   677     {

   678         int argc = 0;

   679         QApplication app(argc, 0, QApplication::GuiServer);

   680         QTimer timer;

   681         timer.setInterval(100);

   682 

   683         QSignalSpy spy(&app, SIGNAL(aboutToQuit()));

   684         QSignalSpy spy2(&timer, SIGNAL(timeout()));

   685 

   686         QPointer<QMainWindow> mainWindow = new QMainWindow;

   687         QPointer<QDialog> dialog = new QDialog(mainWindow);

   688 

   689         QVERIFY(app.quitOnLastWindowClosed());

   690         QVERIFY(mainWindow->testAttribute(Qt::WA_QuitOnClose));

   691         QVERIFY(dialog->testAttribute(Qt::WA_QuitOnClose));

   692 

   693         mainWindow->show();

   694         dialog->show();

   695 

   696         timer.start();

   697         QTimer::singleShot(1000, mainWindow, SLOT(close())); // This should quit the application

   698         QTimer::singleShot(2000, &app, SLOT(quit()));        // This makes sure we quit even if it didn't

   699 

   700         app.exec();

   701 

   702         QCOMPARE(spy.count(), 1);

   703         QVERIFY(spy2.count() < 15);      // Should be around 10 if closing caused the quit

   704     }

   705     {

   706         int argc = 0;

   707         QApplication app(argc, 0, QApplication::GuiServer);

   708         QTimer timer;

   709         timer.setInterval(100);

   710 

   711         QSignalSpy spy(&app, SIGNAL(aboutToQuit()));

   712         QSignalSpy spy2(&timer, SIGNAL(timeout()));

   713 

   714         QPointer<QMainWindow> mainWindow = new QMainWindow;

   715         QPointer<QWidget> invisibleTopLevelWidget = new QWidget;

   716         invisibleTopLevelWidget->setAttribute(Qt::WA_DontShowOnScreen);

   717 

   718         QVERIFY(app.quitOnLastWindowClosed());

   719         QVERIFY(mainWindow->testAttribute(Qt::WA_QuitOnClose));

   720         QVERIFY(invisibleTopLevelWidget->testAttribute(Qt::WA_QuitOnClose));

   721         QVERIFY(invisibleTopLevelWidget->testAttribute(Qt::WA_DontShowOnScreen));

   722 

   723         mainWindow->show();

   724         invisibleTopLevelWidget->show();

   725 

   726         timer.start();

   727         QTimer::singleShot(1000, mainWindow, SLOT(close())); // This should quit the application

   728         QTimer::singleShot(2000, &app, SLOT(quit()));        // This makes sure we quit even if it didn't

   729 

   730         app.exec();

   731 

   732         QCOMPARE(spy.count(), 1);

   733         QVERIFY(spy2.count() < 15);      // Should be around 10 if closing caused the quit

   734     }

   735     {

   736         int argc = 0;

   737         QApplication app(argc, 0, QApplication::GuiServer);

   738         QTimer timer;

   739         timer.setInterval(100);

   740 

   741         QSignalSpy spy(&app, SIGNAL(aboutToQuit()));

   742         QSignalSpy spy2(&timer, SIGNAL(timeout()));

   743 

   744         QPointer<CloseEventTestWindow> mainWindow = new CloseEventTestWindow;

   745 

   746         QVERIFY(app.quitOnLastWindowClosed());

   747         QVERIFY(mainWindow->testAttribute(Qt::WA_QuitOnClose));

   748 

   749         mainWindow->show();

   750 

   751         timer.start();

   752         QTimer::singleShot(1000, mainWindow, SLOT(close())); // This should quit the application

   753         QTimer::singleShot(2000, &app, SLOT(quit()));        // This makes sure we quit even if it didn't

   754 

   755         app.exec();

   756 

   757         QCOMPARE(spy.count(), 1);

   758         QVERIFY(spy2.count() > 15);      // Should be around 20 if closing did not caused the quit

   759     }

   760     {

   761         int argc = 0;

   762         QApplication app(argc, 0, QApplication::GuiServer);

   763         QSignalSpy appSpy(&app, SIGNAL(lastWindowClosed()));

   764 

   765         // exec a dialog for 1 second, then show the window

   766         QuitOnLastWindowClosedWindow window;

   767         QTimer::singleShot(0, &window, SLOT(execDialogThenShow()));

   768 

   769         QTimer timer;

   770         QSignalSpy timerSpy(&timer, SIGNAL(timeout()));

   771         connect(&timer, SIGNAL(timeout()), &window, SLOT(close()));

   772         timer.setSingleShot(true);

   773         timer.start(2000);

   774         int returnValue = app.exec();

   775         QCOMPARE(returnValue, 0);

   776         // failure here means the timer above didn't fire, and the

   777         // quit was caused the the dialog being closed (not the window)

   778         QCOMPARE(timerSpy.count(), 1);

   779         QCOMPARE(appSpy.count(), 2);

   780     }

   781 }

   782 

   783 bool isPathListIncluded(const QStringList &l, const QStringList &r)

   784 {

   785     int size = r.count();

   786     if (size > l.count())

   787         return false;

   788 #if defined (Q_OS_WIN)

   789     Qt::CaseSensitivity cs = Qt::CaseInsensitive;

   790 #else

   791     Qt::CaseSensitivity cs = Qt::CaseSensitive;

   792 #endif

   793     int i = 0, j = 0;

   794     for ( ; i < l.count() && j < r.count(); ++i) {

   795         if (QDir::toNativeSeparators(l[i]).compare(QDir::toNativeSeparators(r[j]), cs) == 0) {

   796             ++j;

   797             i = -1;

   798         }

   799     }

   800     return j == r.count();

   801 }

   802 

   803 #define QT_TST_QAPP_DEBUG

   804 void tst_QApplication::libraryPaths()

   805 {

   806     {

   807 #ifndef Q_OS_WINCE

   808         QString testDir = QDir::current().canonicalPath() + "/test";

   809 #else

   810         // On Windows CE we need QApplication object to have valid

   811         // current Path. Therefore we need to identify it ourselves

   812         // here for the test.

   813         QFileInfo filePath;

   814         wchar_t module_name[MAX_PATH];

   815         GetModuleFileName(0, module_name, MAX_PATH);

   816         filePath = QString::fromWCharArray(module_name);

   817         QString testDir = filePath.path() + "/test";

   818 #endif

   819         QApplication::setLibraryPaths(QStringList() << testDir);

   820         QCOMPARE(QApplication::libraryPaths(), (QStringList() << testDir));

   821 

   822         // creating QApplication adds the applicationDirPath to the libraryPath

   823         int argc = 1;

   824         QApplication app(argc, &argv0, QApplication::GuiServer);

   825         QString appDirPath = QDir(app.applicationDirPath()).canonicalPath();

   826 

   827         QStringList actual = QApplication::libraryPaths();

   828         actual.sort();

   829         QStringList expected = QSet<QString>::fromList((QStringList() << testDir << appDirPath)).toList();

   830         expected.sort();

   831 

   832         QVERIFY2(isPathListIncluded(actual, expected),

   833                  qPrintable("actual:\n - " + actual.join("\n - ") +

   834                             "\nexpected:\n - " + expected.join("\n - ")));

   835     }

   836     {

   837         // creating QApplication adds the applicationDirPath and plugin install path to the libraryPath

   838         int argc = 1;

   839         QApplication app(argc, &argv0, QApplication::GuiServer);

   840         QString appDirPath = app.applicationDirPath();

   841         QString installPathPlugins =  QLibraryInfo::location(QLibraryInfo::PluginsPath);

   842 

   843         QStringList actual = QApplication::libraryPaths();

   844         actual.sort();

   845 

   846 #if defined(Q_OS_SYMBIAN)

   847         QStringList expected;

   848         addExpectedSymbianPluginsPath(expected);

   849         expected << appDirPath;

   850 #else

   851         QStringList expected = QSet<QString>::fromList((QStringList() << installPathPlugins << appDirPath)).toList();

   852 #endif

   853         expected.sort();

   854 

   855         QVERIFY2(isPathListIncluded(actual, expected),

   856                  qPrintable("actual:\n - " + actual.join("\n - ") +

   857                             "\nexpected:\n - " + expected.join("\n - ")));

   858 

   859         // setting the library paths overrides everything

   860         QString testDir = QDir::currentPath() + "/test";

   861         QApplication::setLibraryPaths(QStringList() << testDir);

   862         QVERIFY2(isPathListIncluded(QApplication::libraryPaths(), (QStringList() << testDir)),

   863                  qPrintable("actual:\n - " + QApplication::libraryPaths().join("\n - ") +

   864                             "\nexpected:\n - " + testDir));

   865     }

   866     {

   867 #ifdef QT_TST_QAPP_DEBUG

   868         qDebug() << "Initial library path:" << QApplication::libraryPaths();

   869 #endif

   870 

   871         int count = QApplication::libraryPaths().count();

   872 #if 0

   873         // this test doesn't work if KDE 4 is installed

   874         QCOMPARE(count, 1); // before creating QApplication, only the PluginsPath is in the libraryPaths()

   875 #endif

   876         QString installPathPlugins =  QLibraryInfo::location(QLibraryInfo::PluginsPath);

   877         QApplication::addLibraryPath(installPathPlugins);

   878 #ifdef QT_TST_QAPP_DEBUG

   879         qDebug() << "installPathPlugins" << installPathPlugins;

   880         qDebug() << "After adding plugins path:" << QApplication::libraryPaths();

   881 #endif

   882         QCOMPARE(QApplication::libraryPaths().count(), count);

   883 

   884         QApplication::addLibraryPath(QDir::currentPath() + "/test");

   885         QCOMPARE(QApplication::libraryPaths().count(), count + 1);

   886 

   887         // creating QApplication adds the applicationDirPath to the libraryPath

   888         int argc = 1;

   889         QApplication app(argc, &argv0, QApplication::GuiServer);

   890         QString appDirPath = app.applicationDirPath();

   891         qDebug() << QApplication::libraryPaths();

   892         // On Windows CE these are identical and might also be the case for other

   893         // systems too

   894         if (appDirPath != installPathPlugins)

   895             QCOMPARE(QApplication::libraryPaths().count(), count + 2);

   896     }

   897     {

   898         int argc = 1;

   899         QApplication app(argc, &argv0, QApplication::GuiServer);

   900 

   901 #ifdef QT_TST_QAPP_DEBUG

   902         qDebug() << "Initial library path:" << app.libraryPaths();

   903 #endif

   904         int count = app.libraryPaths().count();

   905         QString installPathPlugins =  QLibraryInfo::location(QLibraryInfo::PluginsPath);

   906         app.addLibraryPath(installPathPlugins);

   907 #ifdef QT_TST_QAPP_DEBUG

   908         qDebug() << "installPathPlugins" << installPathPlugins;

   909         qDebug() << "After adding plugins path:" << app.libraryPaths();

   910 #endif

   911         QCOMPARE(app.libraryPaths().count(), count);

   912 

   913         QString appDirPath = app.applicationDirPath();

   914 

   915         app.addLibraryPath(appDirPath);

   916 #ifdef Q_OS_WINCE

   917         app.addLibraryPath(appDirPath + "/../..");

   918 #else

   919         app.addLibraryPath(appDirPath + "/..");

   920 #endif

   921 #ifdef QT_TST_QAPP_DEBUG

   922         qDebug() << "appDirPath" << appDirPath;

   923         qDebug() << "After adding appDirPath && appDirPath + /..:" << app.libraryPaths();

   924 #endif

   925         QCOMPARE(app.libraryPaths().count(), count + 1);

   926 #ifdef Q_OS_MAC

   927         app.addLibraryPath(appDirPath + "/../MacOS");

   928 #else

   929         app.addLibraryPath(appDirPath + "/tmp/..");

   930 #endif

   931 #ifdef QT_TST_QAPP_DEBUG

   932         qDebug() << "After adding appDirPath + /tmp/..:" << app.libraryPaths();

   933 #endif

   934         QCOMPARE(app.libraryPaths().count(), count + 1);

   935     }

   936 }

   937 

   938 void tst_QApplication::libraryPaths_qt_plugin_path()

   939 {

   940     int argc = 1;

   941 

   942     QApplication app(argc, &argv0, QApplication::GuiServer);

   943     QString appDirPath = app.applicationDirPath();

   944 

   945     // Our hook into libraryPaths() initialization: Set the QT_PLUGIN_PATH environment variable

   946     QString installPathPluginsDeCanon = appDirPath + QString::fromLatin1("/tmp/..");

   947     QByteArray ascii = installPathPluginsDeCanon.toAscii();

   948     qputenv("QT_PLUGIN_PATH", ascii);

   949 

   950     QVERIFY(!app.libraryPaths().contains(appDirPath + QString::fromLatin1("/tmp/..")));

   951 }

   952 

   953 void tst_QApplication::libraryPaths_qt_plugin_path_2()

   954 {

   955 #ifdef Q_OS_SYMBIAN

   956     QByteArray validPath = "C:\\data";

   957     QByteArray nonExistentPath = "Z:\\nonexistent";

   958     QByteArray pluginPath = validPath + ";" + nonExistentPath;

   959 #elif defined(Q_OS_UNIX)

   960     QByteArray validPath = QDir("/tmp").canonicalPath().toLatin1();

   961     QByteArray nonExistentPath = "/nonexistent";

   962     QByteArray pluginPath = validPath + ":" + nonExistentPath;

   963 #elif defined(Q_OS_WIN)

   964 # ifdef Q_OS_WINCE

   965     QByteArray validPath = "/Temp";

   966     QByteArray nonExistentPath = "/nonexistent";

   967     QByteArray pluginPath = validPath + ";" + nonExistentPath;

   968 # else

   969     QByteArray validPath = "C:\\windows";

   970     QByteArray nonExistentPath = "Z:\\nonexistent";

   971     QByteArray pluginPath = validPath + ";" + nonExistentPath;

   972 # endif

   973 #endif

   974 

   975     {

   976         // Our hook into libraryPaths() initialization: Set the QT_PLUGIN_PATH environment variable

   977         qputenv("QT_PLUGIN_PATH", pluginPath);

   978 

   979         int argc = 1;

   980 

   981         QApplication app(argc, &argv0, QApplication::GuiServer);

   982 

   983         // library path list should contain the default plus the one valid path

   984 #if defined(Q_OS_SYMBIAN)

   985         // In Symbian, the PluginsPath doesn't specify the only absolute path; just the dir that can be found on any drive

   986         QStringList expected;

   987         addExpectedSymbianPluginsPath(expected);

   988         expected << QDir(app.applicationDirPath()).canonicalPath()

   989             << QDir(QDir::fromNativeSeparators(QString::fromLatin1(validPath))).canonicalPath();

   990 #else

   991         QStringList expected =

   992             QStringList()

   993             << QLibraryInfo::location(QLibraryInfo::PluginsPath)

   994             << QDir(app.applicationDirPath()).canonicalPath()

   995             << QDir(QDir::fromNativeSeparators(QString::fromLatin1(validPath))).canonicalPath();

   996 # ifdef Q_OS_WINCE

   997         expected = QSet<QString>::fromList(expected).toList();

   998 # endif

   999 #endif

  1000         QVERIFY2(isPathListIncluded(app.libraryPaths(), expected),

  1001                  qPrintable("actual:\n - " + app.libraryPaths().join("\n - ") +

  1002                             "\nexpected:\n - " + expected.join("\n - ")));

  1003     }

  1004 

  1005     {

  1006         int argc = 1;

  1007 

  1008         QApplication app(argc, &argv0, QApplication::GuiServer);

  1009 

  1010         // library paths are initialized by the QApplication, setting

  1011         // the environment variable here doesn't work

  1012         qputenv("QT_PLUGIN_PATH", pluginPath);

  1013 

  1014         // library path list should contain the default

  1015 #if defined(Q_OS_SYMBIAN)

  1016         QStringList expected;

  1017         addExpectedSymbianPluginsPath(expected);

  1018         expected << app.applicationDirPath();

  1019 #else

  1020         QStringList expected =

  1021             QStringList()

  1022             << QLibraryInfo::location(QLibraryInfo::PluginsPath)

  1023             << app.applicationDirPath();

  1024 # ifdef Q_OS_WINCE

  1025         expected = QSet<QString>::fromList(expected).toList();

  1026 # endif

  1027 #endif

  1028         QVERIFY(isPathListIncluded(app.libraryPaths(), expected));

  1029 

  1030         qputenv("QT_PLUGIN_PATH", QByteArray());

  1031     }

  1032 }

  1033 

  1034 class SendPostedEventsTester : public QObject

  1035 {

  1036     Q_OBJECT

  1037 public:

  1038     QList<int> eventSpy;

  1039     bool event(QEvent *e);

  1040 private slots:

  1041     void doTest();

  1042 };

  1043 

  1044 bool SendPostedEventsTester::event(QEvent *e)

  1045 {

  1046     eventSpy.append(e->type());

  1047     return QObject::event(e);

  1048 }

  1049 

  1050 void SendPostedEventsTester::doTest()

  1051 {

  1052     QPointer<SendPostedEventsTester> p = this;

  1053     QApplication::postEvent(this, new QEvent(QEvent::User));

  1054     // DeferredDelete should not be delivered until returning from this function

  1055     QApplication::postEvent(this, new QEvent(QEvent::DeferredDelete));

  1056 

  1057     QEventLoop eventLoop;

  1058     QMetaObject::invokeMethod(&eventLoop, "quit", Qt::QueuedConnection);

  1059     eventLoop.exec();

  1060     QVERIFY(p != 0);

  1061 

  1062     QCOMPARE(eventSpy.count(), 2);

  1063     QCOMPARE(eventSpy.at(0), int(QEvent::MetaCall));

  1064     QCOMPARE(eventSpy.at(1), int(QEvent::User));

  1065     eventSpy.clear();

  1066 }

  1067 

  1068 void tst_QApplication::sendPostedEvents()

  1069 {

  1070     int argc = 0;

  1071     QApplication app(argc, 0, QApplication::GuiServer);

  1072     SendPostedEventsTester *tester = new SendPostedEventsTester;

  1073     QMetaObject::invokeMethod(tester, "doTest", Qt::QueuedConnection);

  1074     QMetaObject::invokeMethod(&app, "quit", Qt::QueuedConnection);

  1075     QPointer<SendPostedEventsTester> p = tester;

  1076     (void) app.exec();

  1077     QVERIFY(p == 0);

  1078 }

  1079 

  1080 void tst_QApplication::thread()

  1081 {

  1082     QThread *currentThread = QThread::currentThread();

  1083     // no app, but still have a valid thread

  1084     QVERIFY(currentThread != 0);

  1085 

  1086     // the thread should be running and not finished

  1087     QVERIFY(currentThread->isRunning());

  1088     QVERIFY(!currentThread->isFinished());

  1089 

  1090     // this should probably be in the tst_QObject::thread() test, but

  1091     // we put it here since we want to make sure that objects created

  1092     // *before* the QApplication has a thread

  1093     QObject object;

  1094     QObject child(&object);

  1095     QVERIFY(object.thread() == currentThread);

  1096     QVERIFY(child.thread() == currentThread);

  1097 

  1098     {

  1099         int argc = 0;

  1100         QApplication app(argc, 0, QApplication::GuiServer);

  1101 

  1102         // current thread still valid

  1103         QVERIFY(QThread::currentThread() != 0);

  1104         // thread should be the same as before

  1105         QCOMPARE(QThread::currentThread(), currentThread);

  1106 

  1107         // app's thread should be the current thread

  1108         QCOMPARE(app.thread(), currentThread);

  1109 

  1110         // the thread should still be running and not finished

  1111         QVERIFY(currentThread->isRunning());

  1112         QVERIFY(!currentThread->isFinished());

  1113 

  1114         QTestEventLoop::instance().enterLoop(1);

  1115     }

  1116 

  1117     // app dead, current thread still valid

  1118     QVERIFY(QThread::currentThread() != 0);

  1119     QCOMPARE(QThread::currentThread(), currentThread);

  1120 

  1121     // the thread should still be running and not finished

  1122     QVERIFY(currentThread->isRunning());

  1123     QVERIFY(!currentThread->isFinished());

  1124 

  1125     // should still have a thread

  1126     QVERIFY(object.thread() == currentThread);

  1127     QVERIFY(child.thread() == currentThread);

  1128 

  1129     // do the test again, making sure that the thread is the same as

  1130     // before

  1131     {

  1132         int argc = 0;

  1133         QApplication app(argc, 0, QApplication::GuiServer);

  1134