← Back to branch summary

~ubuntu-branches/ubuntu/wily/qtbase-opensource-src/wily

« back to all changes in this revision

Viewing changes to tests/auto/widgets/dialogs/qdialog/tst_qdialog.cpp

  • Committer: Package Import Robot
  • Author(s): Timo Jyrinki
  • Date: 2013-02-05 12:46:17 UTC
  • Revision ID: package-import@ubuntu.com-20130205124617-c8jouts182j002fx
Tags: upstream-5.0.1+dfsg
Import upstream version 5.0.1+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/auto/widgets/dialogs/qdialog/tst_qdialog.cpp
 
1
/****************************************************************************
 
2
**
 
3
** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
 
4
** Contact: http://www.qt-project.org/legal
 
5
**
 
6
** This file is part of the test suite of the Qt Toolkit.
 
7
**
 
8
** $QT_BEGIN_LICENSE:LGPL$
 
9
** Commercial License Usage
 
10
** Licensees holding valid commercial Qt licenses may use this file in
 
11
** accordance with the commercial license agreement provided with the
 
12
** Software or, alternatively, in accordance with the terms contained in
 
13
** a written agreement between you and Digia.  For licensing terms and
 
14
** conditions see http://qt.digia.com/licensing.  For further information
 
15
** use the contact form at http://qt.digia.com/contact-us.
 
16
**
 
17
** GNU Lesser General Public License Usage
 
18
** Alternatively, this file may be used under the terms of the GNU Lesser
 
19
** General Public License version 2.1 as published by the Free Software
 
20
** Foundation and appearing in the file LICENSE.LGPL included in the
 
21
** packaging of this file.  Please review the following information to
 
22
** ensure the GNU Lesser General Public License version 2.1 requirements
 
23
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 
24
**
 
25
** In addition, as a special exception, Digia gives you certain additional
 
26
** rights.  These rights are described in the Digia Qt LGPL Exception
 
27
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 
28
**
 
29
** GNU General Public License Usage
 
30
** Alternatively, this file may be used under the terms of the GNU
 
31
** General Public License version 3.0 as published by the Free Software
 
32
** Foundation and appearing in the file LICENSE.GPL included in the
 
33
** packaging of this file.  Please review the following information to
 
34
** ensure the GNU General Public License version 3.0 requirements will be
 
35
** met: http://www.gnu.org/copyleft/gpl.html.
 
36
**
 
37
**
 
38
** $QT_END_LICENSE$
 
39
**
 
40
****************************************************************************/
 
41
 
 
42
 
 
43
#include <QtTest/QtTest>
 
44
 
 
45
#include <qdialog.h>
 
46
#include <qapplication.h>
 
47
#include <qlineedit.h>
 
48
#include <qpushbutton.h>
 
49
#include <qstyle.h>
 
50
#include <QVBoxLayout>
 
51
#include <QSizeGrip>
 
52
 
 
53
 
 
54
 
 
55
QT_FORWARD_DECLARE_CLASS(QDialog)
 
56
 
 
57
class tst_QDialog : public QObject
 
58
{
 
59
    Q_OBJECT
 
60
public:
 
61
    tst_QDialog();
 
62
 
 
63
public slots:
 
64
    void initTestCase();
 
65
    void cleanupTestCase();
 
66
private slots:
 
67
    void getSetCheck();
 
68
    void showExtension_data();
 
69
    void showExtension();
 
70
    void defaultButtons();
 
71
    void showMaximized();
 
72
    void showMinimized();
 
73
    void showFullScreen();
 
74
#ifndef Q_OS_WINCE
 
75
    void showAsTool();
 
76
    void toolDialogPosition();
 
77
#endif
 
78
    void deleteMainDefault();
 
79
    void deleteInExec();
 
80
#ifndef QT_NO_SIZEGRIP
 
81
    void showSizeGrip();
 
82
#endif
 
83
    void setVisible();
 
84
    void reject();
 
85
 
 
86
private:
 
87
    QDialog *testWidget;
 
88
};
 
89
 
 
90
// Testing get/set functions
 
91
void tst_QDialog::getSetCheck()
 
92
{
 
93
    QDialog obj1;
 
94
    // QWidget* QDialog::extension()
 
95
    // void QDialog::setExtension(QWidget*)
 
96
    QWidget *var1 = new QWidget;
 
97
    obj1.setExtension(var1);
 
98
    QCOMPARE(var1, obj1.extension());
 
99
    obj1.setExtension((QWidget *)0);
 
100
    QCOMPARE((QWidget *)0, obj1.extension());
 
101
    // No delete var1, since setExtension takes ownership
 
102
 
 
103
    // int QDialog::result()
 
104
    // void QDialog::setResult(int)
 
105
    obj1.setResult(0);
 
106
    QCOMPARE(0, obj1.result());
 
107
    obj1.setResult(INT_MIN);
 
108
    QCOMPARE(INT_MIN, obj1.result());
 
109
    obj1.setResult(INT_MAX);
 
110
    QCOMPARE(INT_MAX, obj1.result());
 
111
}
 
112
 
 
113
// work around function being protected
 
114
class DummyDialog : public QDialog {
 
115
public:
 
116
    DummyDialog(): QDialog(0) {}
 
117
    void showExtension( bool b ) { QDialog::showExtension( b ); }
 
118
};
 
119
 
 
120
class ToolDialog : public QDialog
 
121
{
 
122
public:
 
123
    ToolDialog(QWidget *parent = 0) : QDialog(parent, Qt::Tool), mWasActive(false), tId(-1) {
 
124
    }
 
125
    bool wasActive() const { return mWasActive; }
 
126
 
 
127
    int exec() {
 
128
        tId = startTimer(300);
 
129
        return QDialog::exec();
 
130
    }
 
131
protected:
 
132
    void timerEvent(QTimerEvent *event) {
 
133
        if (tId == event->timerId()) {
 
134
            killTimer(tId);
 
135
            mWasActive = isActiveWindow();
 
136
            reject();
 
137
        }
 
138
    }
 
139
 
 
140
private:
 
141
    int mWasActive;
 
142
    int tId;
 
143
};
 
144
 
 
145
tst_QDialog::tst_QDialog()
 
146
 
 
147
{
 
148
}
 
149
 
 
150
void tst_QDialog::initTestCase()
 
151
{
 
152
    // Create the test class
 
153
    testWidget = new QDialog(0, Qt::X11BypassWindowManagerHint);
 
154
    testWidget->resize(200,200);
 
155
    testWidget->show();
 
156
    qApp->setActiveWindow(testWidget);
 
157
}
 
158
 
 
159
void tst_QDialog::cleanupTestCase()
 
160
{
 
161
    if (testWidget) {
 
162
        delete testWidget;
 
163
        testWidget = 0;
 
164
    }
 
165
}
 
166
 
 
167
void tst_QDialog::showExtension_data()
 
168
{
 
169
    QTest::addColumn<QSize>("dlgSize");
 
170
    QTest::addColumn<QSize>("extSize");
 
171
    QTest::addColumn<bool>("horizontal");
 
172
    QTest::addColumn<QSize>("result");
 
173
 
 
174
    //next we fill it with data
 
175
    QTest::newRow( "data0" )  << QSize(200,100) << QSize(50,50) << false << QSize(200,150);
 
176
    QTest::newRow( "data1" )  << QSize(200,100) << QSize(220,50) << false << QSize(220,150);
 
177
    QTest::newRow( "data2" )  << QSize(200,100) << QSize(50,50) << true << QSize(250,100);
 
178
    QTest::newRow( "data3" )  << QSize(200,100) << QSize(50,120) << true << QSize(250,120);
 
179
}
 
180
 
 
181
void tst_QDialog::showExtension()
 
182
{
 
183
    QFETCH( QSize, dlgSize );
 
184
    QFETCH( QSize, extSize );
 
185
    QFETCH( bool, horizontal );
 
186
 
 
187
    // set geometry of main dialog and extension widget
 
188
    testWidget->setFixedSize( dlgSize );
 
189
    QWidget *ext = new QWidget( testWidget );
 
190
    ext->setFixedSize( extSize );
 
191
    testWidget->setExtension( ext );
 
192
    testWidget->setOrientation( horizontal ? Qt::Horizontal : Qt::Vertical );
 
193
 
 
194
    QCOMPARE( testWidget->size(), dlgSize );
 
195
    QPoint oldPosition = testWidget->pos();
 
196
 
 
197
    // show
 
198
    ((DummyDialog*)testWidget)->showExtension( true );
 
199
//     while ( testWidget->size() == dlgSize )
 
200
//      qApp->processEvents();
 
201
 
 
202
    QTEST( testWidget->size(), "result"  );
 
203
 
 
204
    QCOMPARE(testWidget->pos(), oldPosition);
 
205
 
 
206
    // hide extension. back to old size ?
 
207
    ((DummyDialog*)testWidget)->showExtension( false );
 
208
    QCOMPARE( testWidget->size(), dlgSize );
 
209
 
 
210
    testWidget->setExtension( 0 );
 
211
}
 
212
 
 
213
void tst_QDialog::defaultButtons()
 
214
{
 
215
    QLineEdit *lineEdit = new QLineEdit(testWidget);
 
216
    QPushButton *push = new QPushButton("Button 1", testWidget);
 
217
    QPushButton *pushTwo = new QPushButton("Button 2", testWidget);
 
218
    QPushButton *pushThree = new QPushButton("Button 3", testWidget);
 
219
    pushThree->setAutoDefault(false);
 
220
 
 
221
    //we need to show the buttons. Otherwise they won't get the focus
 
222
    push->show();
 
223
    pushTwo->show();
 
224
    pushThree->show();
 
225
 
 
226
    push->setDefault(true);
 
227
    QVERIFY(push->isDefault());
 
228
 
 
229
    pushTwo->setFocus();
 
230
    QVERIFY(pushTwo->isDefault());
 
231
    pushThree->setFocus();
 
232
    QVERIFY(push->isDefault());
 
233
    lineEdit->setFocus();
 
234
    QVERIFY(push->isDefault());
 
235
 
 
236
    pushTwo->setDefault(true);
 
237
    QVERIFY(pushTwo->isDefault());
 
238
 
 
239
    pushTwo->setFocus();
 
240
    QVERIFY(pushTwo->isDefault());
 
241
    lineEdit->setFocus();
 
242
    QVERIFY(pushTwo->isDefault());
 
243
}
 
244
 
 
245
void tst_QDialog::showMaximized()
 
246
{
 
247
    QDialog dialog(0);
 
248
    dialog.setSizeGripEnabled(true);
 
249
#ifndef QT_NO_SIZEGRIP
 
250
    QSizeGrip *sizeGrip = qFindChild<QSizeGrip *>(&dialog);
 
251
    QVERIFY(sizeGrip);
 
252
#endif
 
253
 
 
254
    dialog.showMaximized();
 
255
    QVERIFY(dialog.isMaximized());
 
256
    QVERIFY(dialog.isVisible());
 
257
#if !defined(QT_NO_SIZEGRIP) && !defined(Q_OS_MAC) && !defined(Q_OS_IRIX) && !defined(Q_OS_HPUX)
 
258
    QVERIFY(!sizeGrip->isVisible());
 
259
#endif
 
260
 
 
261
    dialog.showNormal();
 
262
    QVERIFY(!dialog.isMaximized());
 
263
    QVERIFY(dialog.isVisible());
 
264
#ifndef QT_NO_SIZEGRIP
 
265
    QVERIFY(sizeGrip->isVisible());
 
266
#endif
 
267
 
 
268
    dialog.showMaximized();
 
269
    QVERIFY(dialog.isMaximized());
 
270
    QVERIFY(dialog.isVisible());
 
271
 
 
272
    dialog.hide();
 
273
    QVERIFY(dialog.isMaximized());
 
274
    QVERIFY(!dialog.isVisible());
 
275
 
 
276
    dialog.show();
 
277
    QVERIFY(dialog.isMaximized());
 
278
    QVERIFY(dialog.isVisible());
 
279
 
 
280
    dialog.hide();
 
281
    QVERIFY(dialog.isMaximized());
 
282
    QVERIFY(!dialog.isVisible());
 
283
 
 
284
    dialog.showMaximized();
 
285
    QVERIFY(dialog.isMaximized());
 
286
    QVERIFY(dialog.isVisible());
 
287
}
 
288
 
 
289
void tst_QDialog::showMinimized()
 
290
{
 
291
    QDialog dialog(0);
 
292
 
 
293
    dialog.showMinimized();
 
294
    QVERIFY(dialog.isMinimized());
 
295
    QVERIFY(dialog.isVisible());
 
296
 
 
297
    dialog.showNormal();
 
298
    QVERIFY(!dialog.isMinimized());
 
299
    QVERIFY(dialog.isVisible());
 
300
 
 
301
    dialog.showMinimized();
 
302
    QVERIFY(dialog.isMinimized());
 
303
    QVERIFY(dialog.isVisible());
 
304
 
 
305
    dialog.hide();
 
306
    QVERIFY(dialog.isMinimized());
 
307
    QVERIFY(!dialog.isVisible());
 
308
 
 
309
    dialog.show();
 
310
    QVERIFY(dialog.isMinimized());
 
311
    QVERIFY(dialog.isVisible());
 
312
 
 
313
    dialog.hide();
 
314
    QVERIFY(dialog.isMinimized());
 
315
    QVERIFY(!dialog.isVisible());
 
316
 
 
317
    dialog.showMinimized();
 
318
    QVERIFY(dialog.isMinimized());
 
319
    QVERIFY(dialog.isVisible());
 
320
}
 
321
 
 
322
void tst_QDialog::showFullScreen()
 
323
{
 
324
    QDialog dialog(0, Qt::X11BypassWindowManagerHint);
 
325
    dialog.setSizeGripEnabled(true);
 
326
#ifndef QT_NO_SIZEGRIP
 
327
    QSizeGrip *sizeGrip = qFindChild<QSizeGrip *>(&dialog);
 
328
    QVERIFY(sizeGrip);
 
329
#endif
 
330
 
 
331
    qApp->syncX();
 
332
    dialog.showFullScreen();
 
333
    QVERIFY(dialog.isFullScreen());
 
334
    QVERIFY(dialog.isVisible());
 
335
#ifndef QT_NO_SIZEGRIP
 
336
    QVERIFY(!sizeGrip->isVisible());
 
337
#endif
 
338
 
 
339
    qApp->syncX();
 
340
    dialog.showNormal();
 
341
    QVERIFY(!dialog.isFullScreen());
 
342
    QVERIFY(dialog.isVisible());
 
343
#ifndef QT_NO_SIZEGRIP
 
344
    QVERIFY(sizeGrip->isVisible());
 
345
#endif
 
346
 
 
347
    qApp->syncX();
 
348
    dialog.showFullScreen();
 
349
    QVERIFY(dialog.isFullScreen());
 
350
    QVERIFY(dialog.isVisible());
 
351
 
 
352
    qApp->syncX();
 
353
    dialog.hide();
 
354
    QVERIFY(dialog.isFullScreen());
 
355
    QVERIFY(!dialog.isVisible());
 
356
 
 
357
    qApp->syncX();
 
358
    dialog.show();
 
359
    QVERIFY(dialog.isFullScreen());
 
360
    QVERIFY(dialog.isVisible());
 
361
 
 
362
    qApp->syncX();
 
363
    dialog.hide();
 
364
    QVERIFY(dialog.isFullScreen());
 
365
    QVERIFY(!dialog.isVisible());
 
366
 
 
367
    qApp->syncX();
 
368
    dialog.showFullScreen();
 
369
    QVERIFY(dialog.isFullScreen());
 
370
    QVERIFY(dialog.isVisible());
 
371
 
 
372
    qApp->syncX();
 
373
    dialog.hide();
 
374
    QVERIFY(dialog.isFullScreen());
 
375
    QVERIFY(!dialog.isVisible());
 
376
}
 
377
 
 
378
// No real support for Qt::Tool on WinCE
 
379
#ifndef Q_OS_WINCE
 
380
void tst_QDialog::showAsTool()
 
381
{
 
382
#if defined(Q_OS_UNIX)
 
383
    QSKIP("Qt/X11: Skipped since activeWindow() is not respected by all window managers");
 
384
#endif
 
385
    ToolDialog dialog(testWidget);
 
386
    testWidget->activateWindow();
 
387
    dialog.exec();
 
388
    QTest::qWait(100);
 
389
    if (testWidget->style()->styleHint(QStyle::SH_Widget_ShareActivation, 0, testWidget)) {
 
390
        QCOMPARE(dialog.wasActive(), true);
 
391
    } else {
 
392
        QCOMPARE(dialog.wasActive(), false);
 
393
    }
 
394
}
 
395
#endif
 
396
 
 
397
// No real support for Qt::Tool on WinCE
 
398
#ifndef Q_OS_WINCE
 
399
// Verify that pos() returns the same before and after show()
 
400
// for a dialog with the Tool window type.
 
401
void tst_QDialog::toolDialogPosition()
 
402
{
 
403
    QDialog dialog(0, Qt::Tool);
 
404
    dialog.move(QPoint(100,100));
 
405
    const QPoint beforeShowPosition = dialog.pos();
 
406
    dialog.show();
 
407
    const QPoint afterShowPosition = dialog.pos();
 
408
    QCOMPARE(afterShowPosition, beforeShowPosition);
 
409
}
 
410
#endif
 
411
 
 
412
class Dialog : public QDialog
 
413
{
 
414
public:
 
415
    Dialog(QPushButton *&button)
 
416
    {
 
417
        button = new QPushButton(this);
 
418
    }
 
419
};
 
420
 
 
421
void tst_QDialog::deleteMainDefault()
 
422
{
 
423
    QPushButton *button;
 
424
    Dialog dialog(button);
 
425
    button->setDefault(true);
 
426
    delete button;
 
427
    dialog.show();
 
428
    QTestEventLoop::instance().enterLoop(2);
 
429
}
 
430
 
 
431
void tst_QDialog::deleteInExec()
 
432
{
 
433
    QDialog *dialog = new QDialog(0);
 
434
    QMetaObject::invokeMethod(dialog, "deleteLater", Qt::QueuedConnection);
 
435
    QCOMPARE(dialog->exec(), int(QDialog::Rejected));
 
436
}
 
437
 
 
438
#ifndef QT_NO_SIZEGRIP
 
439
// From Task 124269
 
440
void tst_QDialog::showSizeGrip()
 
441
{
 
442
    QDialog dialog(0);
 
443
    dialog.show();
 
444
    QWidget *ext = new QWidget(&dialog);
 
445
    QVERIFY(!dialog.extension());
 
446
    QVERIFY(!dialog.isSizeGripEnabled());
 
447
 
 
448
    dialog.setSizeGripEnabled(true);
 
449
    QPointer<QSizeGrip> sizeGrip = qFindChild<QSizeGrip *>(&dialog);
 
450
    QVERIFY(sizeGrip);
 
451
    QVERIFY(sizeGrip->isVisible());
 
452
    QVERIFY(dialog.isSizeGripEnabled());
 
453
 
 
454
    dialog.setExtension(ext);
 
455
    QVERIFY(dialog.extension() && !dialog.extension()->isVisible());
 
456
    QVERIFY(dialog.isSizeGripEnabled());
 
457
 
 
458
    // normal show/hide sequence
 
459
    dialog.showExtension(true);
 
460
    QVERIFY(dialog.extension() && dialog.extension()->isVisible());
 
461
    QVERIFY(!dialog.isSizeGripEnabled());
 
462
    QVERIFY(!sizeGrip);
 
463
 
 
464
    dialog.showExtension(false);
 
465
    QVERIFY(dialog.extension() && !dialog.extension()->isVisible());
 
466
    QVERIFY(dialog.isSizeGripEnabled());
 
467
    sizeGrip = qFindChild<QSizeGrip *>(&dialog);
 
468
    QVERIFY(sizeGrip);
 
469
    QVERIFY(sizeGrip->isVisible());
 
470
 
 
471
    // show/hide sequence with interleaved size grip update
 
472
    dialog.showExtension(true);
 
473
    QVERIFY(dialog.extension() && dialog.extension()->isVisible());
 
474
    QVERIFY(!dialog.isSizeGripEnabled());
 
475
    QVERIFY(!sizeGrip);
 
476
 
 
477
    dialog.setSizeGripEnabled(false);
 
478
    QVERIFY(!dialog.isSizeGripEnabled());
 
479
 
 
480
    dialog.showExtension(false);
 
481
    QVERIFY(dialog.extension() && !dialog.extension()->isVisible());
 
482
    QVERIFY(!dialog.isSizeGripEnabled());
 
483
 
 
484
    dialog.setSizeGripEnabled(true);
 
485
    sizeGrip = qFindChild<QSizeGrip *>(&dialog);
 
486
    QVERIFY(sizeGrip);
 
487
    QVERIFY(sizeGrip->isVisible());
 
488
    sizeGrip->hide();
 
489
    dialog.hide();
 
490
    dialog.show();
 
491
    QVERIFY(!sizeGrip->isVisible());
 
492
}
 
493
#endif
 
494
 
 
495
void tst_QDialog::setVisible()
 
496
{
 
497
    QWidget topLevel;
 
498
    topLevel.show();
 
499
 
 
500
    QDialog *dialog = new QDialog;
 
501
    dialog->setLayout(new QVBoxLayout);
 
502
    dialog->layout()->addWidget(new QPushButton("dialog button"));
 
503
 
 
504
    QWidget *widget = new QWidget(&topLevel);
 
505
    widget->setLayout(new QVBoxLayout);
 
506
    widget->layout()->addWidget(dialog);
 
507
 
 
508
    QVERIFY(!dialog->isVisible());
 
509
    QVERIFY(!dialog->isHidden());
 
510
 
 
511
    widget->show();
 
512
    QVERIFY(dialog->isVisible());
 
513
    QVERIFY(!dialog->isHidden());
 
514
 
 
515
    widget->hide();
 
516
    dialog->hide();
 
517
    widget->show();
 
518
    QVERIFY(!dialog->isVisible());
 
519
    QVERIFY(dialog->isHidden());
 
520
}
 
521
 
 
522
class TestRejectDialog : public QDialog
 
523
{
 
524
    public:
 
525
        TestRejectDialog() : cancelReject(false), called(0) {}
 
526
        void reject()
 
527
        {
 
528
            called++;
 
529
            if (!cancelReject)
 
530
                QDialog::reject();
 
531
        }
 
532
        bool cancelReject;
 
533
        int called;
 
534
};
 
535
 
 
536
void tst_QDialog::reject()
 
537
{
 
538
    TestRejectDialog dialog;
 
539
    dialog.show();
 
540
    QVERIFY(QTest::qWaitForWindowExposed(&dialog));
 
541
    QVERIFY(dialog.isVisible());
 
542
    dialog.reject();
 
543
    QTRY_VERIFY(!dialog.isVisible());
 
544
    QCOMPARE(dialog.called, 1);
 
545
 
 
546
    dialog.show();
 
547
    QVERIFY(QTest::qWaitForWindowExposed(&dialog));
 
548
    QVERIFY(dialog.isVisible());
 
549
    QVERIFY(dialog.close());
 
550
    QTRY_VERIFY(!dialog.isVisible());
 
551
    QCOMPARE(dialog.called, 2);
 
552
 
 
553
    dialog.cancelReject = true;
 
554
    dialog.show();
 
555
    QVERIFY(QTest::qWaitForWindowExposed(&dialog));
 
556
    QVERIFY(dialog.isVisible());
 
557
    dialog.reject();
 
558
    QTRY_VERIFY(dialog.isVisible());
 
559
    QCOMPARE(dialog.called, 3);
 
560
    QVERIFY(!dialog.close());
 
561
    QTRY_VERIFY(dialog.isVisible());
 
562
    QCOMPARE(dialog.called, 4);
 
563
}
 
564
 
 
565
 
 
566
QTEST_MAIN(tst_QDialog)
 
567
#include "tst_qdialog.moc"