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

     2 **

     3 ** Copyright (C) 2009 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 

    57 //TESTED_CLASS=

    58 //TESTED_FILES=

    59 

    60 #if defined(Q_OS_SYMBIAN)

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

    62 static void addExpectedSymbianPluginsPath(QStringList& expected)

    63 {

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

    65     QFileInfoList driveList = QDir::drives();

    66     QListIterator<QFileInfo> iter(driveList);

    67     while (iter.hasNext()) {

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

    69         if (testFi.exists())

    70             expected << testFi.canonicalFilePath();

    71     }

    72 }

    73 #endif

    74 

    75 class tst_QApplication : public QObject

    76 {

    77 Q_OBJECT

    78 

    79 public:

    80     tst_QApplication();

    81     virtual ~tst_QApplication();

    82 

    83 public slots:

    84     void init();

    85     void cleanup();

    86 private slots:

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

    88     void getSetCheck();

    89     void staticSetup();

    90 

    91     void alert();

    92 

    93     void multiple_data();

    94     void multiple();

    95 

    96     void nonGui();

    97 

    98     void setFont_data();

    99     void setFont();

   100 

   101     void args_data();

   102     void args();

   103 

   104     void lastWindowClosed();

   105     void quitOnLastWindowClosed();

   106     void testDeleteLater();

   107     void testDeleteLaterProcessEvents();

   108 

   109     void libraryPaths();

   110     void libraryPaths_qt_plugin_path();

   111     void libraryPaths_qt_plugin_path_2();

   112 

   113     void sendPostedEvents();

   114 

   115     void thread();

   116     void desktopSettingsAware();

   117 

   118     void setActiveWindow();

   119 

   120     void focusChanged();

   121     void focusOut();

   122 

   123     void execAfterExit();

   124 

   125     void wheelScrollLines();

   126 

   127     void task109149();

   128 

   129     void style();

   130 

   131     void allWidgets();

   132 

   133     void setAttribute();

   134 

   135     void windowsCommandLine_data();

   136     void windowsCommandLine();

   137 

   138     void touchEventPropagation();

   139 };

   140 

   141 class EventSpy : public QObject

   142 {

   143    Q_OBJECT

   144 

   145 public:

   146     QList<int> recordedEvents;

   147     bool eventFilter(QObject *, QEvent *event)

   148     {

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

   150         return false;

   151     }

   152 };

   153 

   154 void tst_QApplication::sendEventsOnProcessEvents()

   155 {

   156     int argc = 0;

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

   158 

   159     EventSpy spy;

   160     app.installEventFilter(&spy);

   161 

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

   163     QCoreApplication::processEvents();

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

   165 }

   166 

   167 class MyInputContext : public QInputContext

   168 {

   169 public:

   170     MyInputContext() : QInputContext() {}

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

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

   173     void reset() {}

   174     bool isComposing() const { return false; }

   175 };

   176 

   177 // Testing get/set functions

   178 void tst_QApplication::getSetCheck()

   179 {

   180     int argc = 0;

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

   182     // QInputContext * QApplication::inputContext()

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

   184     MyInputContext *var1 = new MyInputContext;

   185     obj1.setInputContext(var1);

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

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

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

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

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

   191 }

   192 

   193 class CloseEventTestWindow : public QWidget

   194 {

   195 public:

   196     CloseEventTestWindow(QWidget *parent = 0)

   197         : QWidget(parent)

   198     {

   199     }

   200 

   201     void closeEvent(QCloseEvent *event)

   202     {

   203         QWidget dialog;

   204         dialog.show();

   205         dialog.close();

   206 

   207         hide();

   208         event->ignore();

   209     }

   210 };

   211 

   212 static  char *argv0;

   213 

   214 tst_QApplication::tst_QApplication()

   215 {

   216 #ifdef Q_OS_WINCE

   217     // Clean up environment previously to launching test

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

   219 #endif

   220 }

   221 

   222 tst_QApplication::~tst_QApplication()

   223 {

   224 

   225 }

   226 

   227 void tst_QApplication::init()

   228 {

   229 // TODO: Add initialization code here.

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

   231 }

   232 

   233 void tst_QApplication::cleanup()

   234 {

   235 // TODO: Add cleanup code here.

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

   237 }

   238 

   239 void tst_QApplication::staticSetup()

   240 {

   241     QVERIFY(!qApp);

   242 

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

   244     QVERIFY(style);

   245     QApplication::setStyle(style);

   246 

   247     QPalette pal;

   248     QApplication::setPalette(pal);

   249 

   250     /*QFont font;

   251     QApplication::setFont(font);*/

   252 

   253     int argc = 0;

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

   255 }

   256 

   257 

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

   259 class TestApplication : public QApplication

   260 {

   261 public:

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

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

   264     {

   265 	startTimer( 150 );

   266     }

   267 

   268     void timerEvent( QTimerEvent * )

   269     {

   270         quit();

   271     }

   272 };

   273 

   274 void tst_QApplication::alert()

   275 {

   276     int argc = 0;

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

   278     app.alert(0, 0);

   279 

   280     QWidget widget;

   281     QWidget widget2;

   282     app.alert(&widget, 100);

   283     widget.show();

   284     widget2.show();

   285 #ifdef Q_WS_X11

   286     qt_x11_wait_for_window_manager(&widget);

   287     qt_x11_wait_for_window_manager(&widget2);

   288 #endif

   289     QTest::qWait(100);

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

   291     app.alert(&widget, 250);

   292     widget2.activateWindow();

   293     QApplication::setActiveWindow(&widget2);

   294     app.alert(&widget, 0);

   295     widget.activateWindow();

   296     QApplication::setActiveWindow(&widget);

   297     app.alert(&widget, 200);

   298     app.syncX();

   299 }

   300 

   301 void tst_QApplication::multiple_data()

   302 {

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

   304 

   305     // return a list of things to try

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

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

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

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

   310 }

   311 

   312 void tst_QApplication::multiple()

   313 {

   314     QFETCH(QStringList,features);

   315 

   316     int i = 0;

   317     int argc = 0;

   318     while ( i++ < 5 ) {

   319 	TestApplication app( argc, 0 );

   320 

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

   322 	    // create font and force loading

   323 	    QFont font( "Arial", 12 );

   324 	    QFontInfo finfo( font );

   325 	    finfo.exactMatch();

   326 	}

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

   328 	    QPixmap pix( 100, 100 );

   329 	    pix.fill( Qt::black );

   330 	}

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

   332 	    QWidget widget;

   333 	}

   334 

   335 	QVERIFY(!app.exec());

   336     }

   337 }

   338 

   339 void tst_QApplication::nonGui()

   340 {

   341 #ifdef Q_OS_HPUX

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

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

   344 #endif

   345 

   346     int argc = 0;

   347     QApplication app(argc, 0, false);

   348     QCOMPARE(qApp, &app);

   349 }

   350 

   351 void tst_QApplication::setFont_data()

   352 {

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

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

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

   356 

   357     int argc = 0;

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

   359 

   360     int cnt = 0;

   361     QFontDatabase fdb;

   362     QStringList families = fdb.families();

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

   364 	 itr != families.end();

   365 	 ++itr) {

   366 	if (cnt < 3) {

   367 	    QString family = *itr;

   368 	    QStringList styles = fdb.styles(family);

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

   370 		QString style = styles.first();

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

   372 		if (!sizes.size())

   373 		    sizes = fdb.standardSizes();

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

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

   376 			<< family

   377 			<< sizes.first()

   378                         << false;

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

   380 			<< family

   381 			<< sizes.first()

   382                         << true;

   383                 }

   384 	    }

   385 	}

   386 	++cnt;

   387     }

   388 

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

   390         << 0 << false;

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

   392         << 0 << true;

   393 

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

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

   396 

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

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

   399 }

   400 

   401 void tst_QApplication::setFont()

   402 {

   403     QFETCH( QString, family );

   404     QFETCH( int, pointsize );

   405     QFETCH( bool, beforeAppConstructor );

   406 

   407     QFont font( family, pointsize );

   408     if (beforeAppConstructor) {

   409         QApplication::setFont( font );

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

   411     }

   412 

   413     int argc = 0;

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

   415     if (!beforeAppConstructor)

   416         QApplication::setFont( font );

   417 

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

   419 }

   420 

   421 void tst_QApplication::args_data()

   422 {

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

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

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

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

   427 

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

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

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

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

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

   433 }

   434 

   435 void tst_QApplication::task109149()

   436 {

   437     int argc = 0;

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

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

   440 

   441     QWidget w;

   442     w.setWindowTitle("hello");

   443     w.show();

   444 

   445     app.processEvents();

   446 }

   447 

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

   449 {

   450     static QList<QByteArray> cache;

   451 

   452     int i;

   453     char **argarray = 0;

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

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

   456 

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

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

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

   460         cache.append(l1);

   461     }

   462     argarray[i] = 0;

   463 

   464     return argarray;

   465 }

   466 

   467 static QString cstrings2QString( char **args )

   468 {

   469     QString string;

   470     if ( !args )

   471 	return string;

   472 

   473     int i = 0;

   474     while ( args[i] ) {

   475 	string += args[i];

   476 	if ( args[i+1] )

   477 	    string += " ";

   478 	++i;

   479     }

   480     return string;

   481 }

   482 

   483 void tst_QApplication::args()

   484 {

   485     QFETCH( int, argc_in );

   486     QFETCH( QString, args_in );

   487     QFETCH( int, argc_out );

   488     QFETCH( QString, args_out );

   489 

   490     char **argv = QString2cstrings( args_in );

   491 

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

   493     QString argv_out = cstrings2QString(argv);

   494 

   495     QCOMPARE( argc_in, argc_out );

   496     QCOMPARE( argv_out, args_out );

   497 

   498     delete [] argv;

   499 }

   500 

   501 class CloseWidget : public QWidget

   502 {

   503     Q_OBJECT

   504 public:

   505     CloseWidget()

   506     {

   507         startTimer(500);

   508     }

   509 

   510 protected:

   511     void timerEvent(QTimerEvent *)

   512     {

   513         close();

   514     }

   515 

   516 };

   517 

   518 void tst_QApplication::lastWindowClosed()

   519 {

   520     int argc = 0;

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

   522 

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

   524 

   525     QPointer<QDialog> dialog = new QDialog;

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

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

   528     dialog->exec();

   529     QVERIFY(dialog);

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

   531 

   532     QPointer<CloseWidget>widget = new CloseWidget;

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

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

   535     app.exec();

   536     QVERIFY(!widget);

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

   538     spy.clear();

   539 

   540 #if 0

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

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

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

   544     app.exec();

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

   546 #endif

   547 

   548     delete dialog;

   549 

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

   551     QWidget w1;

   552     QWidget w2;

   553     QWidget w3;

   554     w1.show();

   555     w2.show();

   556     w3.show();

   557 

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

   559     app.exec();

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

   561 }

   562 

   563 class QuitOnLastWindowClosedDialog : public QDialog

   564 {

   565     Q_OBJECT

   566 public:

   567     QPushButton *okButton;

   568 

   569     QuitOnLastWindowClosedDialog()

   570     {

   571         QHBoxLayout *hbox = new QHBoxLayout(this);

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

   573 

   574         hbox->addWidget(okButton);

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

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

   577     }

   578 

   579 public slots:

   580     void ok_clicked()

   581     {

   582         QDialog other;

   583 

   584         QTimer timer;

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

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

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

   588 

   589         timer.start(1000);

   590         other.exec();

   591 

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

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

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

   595     }

   596 };

   597 

   598 class QuitOnLastWindowClosedWindow : public QWidget

   599 {

   600     Q_OBJECT

   601 

   602 public:

   603     QuitOnLastWindowClosedWindow()

   604     { }

   605 

   606 public slots:

   607     void execDialogThenShow()

   608     {

   609         QDialog dialog;

   610         QTimer timer1;

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

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

   613         timer1.setSingleShot(true);

   614         timer1.start(1000);

   615         dialog.exec();

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

   617 

   618         show();

   619     }

   620 };

   621 

   622 void tst_QApplication::quitOnLastWindowClosed()

   623 {

   624     {

   625         int argc = 0;

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

   627 

   628         QuitOnLastWindowClosedDialog d;

   629         d.show();

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

   631 

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

   633         app.exec();

   634 

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

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

   637     }

   638     {

   639         int argc = 0;

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

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

   642 

   643         QDialog dialog;

   644         QTimer timer1;

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

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

   647         timer1.setSingleShot(true);

   648         timer1.start(1000);

   649         dialog.exec();

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

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

   652 

   653         QTimer timer2;

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

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

   656         timer2.setSingleShot(true);

   657         timer2.start(1000);

   658         int returnValue = app.exec();

   659         QCOMPARE(returnValue, 0);

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

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

   662     }

   663     {

   664         int argc = 0;

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

   666         QTimer timer;

   667         timer.setInterval(100);

   668 

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

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

   671 

   672         QPointer<QMainWindow> mainWindow = new QMainWindow;

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

   674 

   675         QVERIFY(app.quitOnLastWindowClosed());

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

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

   678 

   679         mainWindow->show();

   680         dialog->show();

   681 

   682         timer.start();

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

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

   685 

   686         app.exec();

   687 

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

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

   690     }

   691     {

   692         int argc = 0;

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

   694         QTimer timer;

   695         timer.setInterval(100);

   696 

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

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

   699 

   700         QPointer<QMainWindow> mainWindow = new QMainWindow;

   701         QPointer<QWidget> invisibleTopLevelWidget = new QWidget;

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

   703 

   704         QVERIFY(app.quitOnLastWindowClosed());

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

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

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

   708 

   709         mainWindow->show();

   710         invisibleTopLevelWidget->show();

   711 

   712         timer.start();

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

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

   715 

   716         app.exec();

   717 

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

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

   720     }

   721     {

   722         int argc = 0;

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

   724         QTimer timer;

   725         timer.setInterval(100);

   726 

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

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

   729 

   730         QPointer<CloseEventTestWindow> mainWindow = new CloseEventTestWindow;

   731 

   732         QVERIFY(app.quitOnLastWindowClosed());

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

   734 

   735         mainWindow->show();

   736 

   737         timer.start();

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

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

   740 

   741         app.exec();

   742 

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

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

   745     }

   746     {

   747         int argc = 0;

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

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

   750 

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

   752         QuitOnLastWindowClosedWindow window;

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

   754 

   755         QTimer timer;

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

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

   758         timer.setSingleShot(true);

   759         timer.start(2000);

   760         int returnValue = app.exec();

   761         QCOMPARE(returnValue, 0);

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

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

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

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

   766     }

   767 }

   768 

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

   770 {

   771     int size = r.count();

   772     if (size > l.count())

   773         return false;

   774 #if defined (Q_OS_WIN)

   775     Qt::CaseSensitivity cs = Qt::CaseInsensitive;

   776 #else

   777     Qt::CaseSensitivity cs = Qt::CaseSensitive;

   778 #endif

   779     int i = 0, j = 0;

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

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

   782             ++j;

   783             i = -1;

   784         }

   785     }

   786     return j == r.count();

   787 }

   788 

   789 #define QT_TST_QAPP_DEBUG

   790 void tst_QApplication::libraryPaths()

   791 {

   792     {

   793 #ifndef Q_OS_WINCE

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

   795 #else

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

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

   798         // here for the test.

   799         QFileInfo filePath;

   800         wchar_t module_name[MAX_PATH];

   801         GetModuleFileName(0, module_name, MAX_PATH);

   802         filePath = QString::fromWCharArray(module_name);

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

   804 #endif

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

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

   807 

   808         // creating QApplication adds the applicationDirPath to the libraryPath

   809         int argc = 1;

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

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

   812 

   813         QStringList actual = QApplication::libraryPaths();

   814         actual.sort();

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

   816         expected.sort();

   817 

   818         QVERIFY2(isPathListIncluded(actual, expected),

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

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

   821     }

   822     {

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

   824         int argc = 1;

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

   826         QString appDirPath = app.applicationDirPath();

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

   828 

   829         QStringList actual = QApplication::libraryPaths();

   830         actual.sort();

   831 

   832 #if defined(Q_OS_SYMBIAN)

   833         QStringList expected;

   834         addExpectedSymbianPluginsPath(expected);

   835         expected << appDirPath;

   836 #else

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

   838 #endif

   839         expected.sort();

   840 

   841         QVERIFY2(isPathListIncluded(actual, expected),

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

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

   844 

   845         // setting the library paths overrides everything

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

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

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

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

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

   851     }

   852     {

   853 #ifdef QT_TST_QAPP_DEBUG

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

   855 #endif

   856 

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

   858 #if 0

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

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

   861 #endif

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

   863         QApplication::addLibraryPath(installPathPlugins);

   864 #ifdef QT_TST_QAPP_DEBUG

   865         qDebug() << "installPathPlugins" << installPathPlugins;

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

   867 #endif

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

   869 

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

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

   872 

   873         // creating QApplication adds the applicationDirPath to the libraryPath

   874         int argc = 1;

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

   876         QString appDirPath = app.applicationDirPath();

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

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

   879         // systems too

   880         if (appDirPath != installPathPlugins)

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

   882     }

   883     {

   884         int argc = 1;

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

   886 

   887 #ifdef QT_TST_QAPP_DEBUG

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

   889 #endif

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

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

   892         app.addLibraryPath(installPathPlugins);

   893 #ifdef QT_TST_QAPP_DEBUG

   894         qDebug() << "installPathPlugins" << installPathPlugins;

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

   896 #endif

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

   898 

   899         QString appDirPath = app.applicationDirPath();

   900 

   901         app.addLibraryPath(appDirPath);

   902 #ifdef Q_OS_WINCE

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

   904 #else

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

   906 #endif

   907 #ifdef QT_TST_QAPP_DEBUG

   908         qDebug() << "appDirPath" << appDirPath;

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

   910 #endif

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

   912 #ifdef Q_OS_MAC

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

   914 #else

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

   916 #endif

   917 #ifdef QT_TST_QAPP_DEBUG

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

   919 #endif

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

   921     }

   922 }

   923 

   924 void tst_QApplication::libraryPaths_qt_plugin_path()

   925 {

   926     int argc = 1;

   927 

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

   929     QString appDirPath = app.applicationDirPath();

   930 

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

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

   933     QByteArray ascii = installPathPluginsDeCanon.toAscii();

   934     qputenv("QT_PLUGIN_PATH", ascii);

   935 

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

   937 }

   938 

   939 void tst_QApplication::libraryPaths_qt_plugin_path_2()

   940 {

   941 #ifdef Q_OS_SYMBIAN

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

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

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

   945 #elif defined(Q_OS_UNIX)

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

   947     QByteArray nonExistentPath = "/nonexistent";

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

   949 #elif defined(Q_OS_WIN)

   950 # ifdef Q_OS_WINCE

   951     QByteArray validPath = "/Temp";

   952     QByteArray nonExistentPath = "/nonexistent";

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

   954 # else

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

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

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

   958 # endif

   959 #endif

   960 

   961     {

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

   963         qputenv("QT_PLUGIN_PATH", pluginPath);

   964 

   965         int argc = 1;

   966 

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

   968 

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

   970 #if defined(Q_OS_SYMBIAN)

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

   972         QStringList expected;

   973         addExpectedSymbianPluginsPath(expected);

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

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

   976 #else

   977         QStringList expected =

   978             QStringList()

   979             << QLibraryInfo::location(QLibraryInfo::PluginsPath)

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

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

   982 # ifdef Q_OS_WINCE

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

   984 # endif

   985 #endif

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

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

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

   989     }

   990 

   991     {

   992         int argc = 1;

   993 

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

   995 

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

   997         // the environment variable here doesn't work

   998         qputenv("QT_PLUGIN_PATH", pluginPath);

   999 

  1000         // library path list should contain the default

  1001 #if defined(Q_OS_SYMBIAN)

  1002         QStringList expected;

  1003         addExpectedSymbianPluginsPath(expected);

  1004         expected << app.applicationDirPath();

  1005 #else

  1006         QStringList expected =

  1007             QStringList()

  1008             << QLibraryInfo::location(QLibraryInfo::PluginsPath)

  1009             << app.applicationDirPath();

  1010 # ifdef Q_OS_WINCE

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

  1012 # endif

  1013 #endif

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

  1015 

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

  1017     }

  1018 }

  1019 

  1020 class SendPostedEventsTester : public QObject

  1021 {

  1022     Q_OBJECT

  1023 public:

  1024     QList<int> eventSpy;

  1025     bool event(QEvent *e);

  1026 private slots:

  1027     void doTest();

  1028 };

  1029 

  1030 bool SendPostedEventsTester::event(QEvent *e)

  1031 {

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

  1033     return QObject::event(e);

  1034 }

  1035 

  1036 void SendPostedEventsTester::doTest()

  1037 {

  1038     QPointer<SendPostedEventsTester> p = this;

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

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

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

  1042 

  1043     QEventLoop eventLoop;

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

  1045     eventLoop.exec();

  1046     QVERIFY(p != 0);

  1047 

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

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

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

  1051     eventSpy.clear();

  1052 }

  1053 

  1054 void tst_QApplication::sendPostedEvents()

  1055 {

  1056     int argc = 0;

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

  1058     SendPostedEventsTester *tester = new SendPostedEventsTester;

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

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

  1061     QPointer<SendPostedEventsTester> p = tester;

  1062     (void) app.exec();

  1063     QVERIFY(p == 0);

  1064 }

  1065 

  1066 void tst_QApplication::thread()

  1067 {

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

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

  1070     QVERIFY(currentThread != 0);

  1071 

  1072     // the thread should be running and not finished

  1073     QVERIFY(currentThread->isRunning());

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

  1075 

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

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

  1078     // *before* the QApplication has a thread

  1079     QObject object;

  1080     QObject child(&object);

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

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

  1083 

  1084     {

  1085         int argc = 0;

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

  1087 

  1088         // current thread still valid

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

  1090         // thread should be the same as before

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

  1092 

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

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

  1095 

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

  1097         QVERIFY(currentThread->isRunning());

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

  1099 

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

  1101     }

  1102 

  1103     // app dead, current thread still valid

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

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

  1106 

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

  1108     QVERIFY(currentThread->isRunning());

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

  1110 

  1111     // should still have a thread

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

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

  1114 

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

  1116     // before

  1117     {

  1118         int argc = 0;

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

  1120 

  1121         // current thread still valid

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

  1123         // thread should be the same as before

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

  1125 

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

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

  1128 

  1129         // the thread should be running and not finished

  1130         QVERIFY(currentThread->isRunning());

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

  1132 

  1133         // should still have a thread

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