1 /****************************************************************************
2 **
3 ** Copyright (C) 2015 The Qt Company Ltd.
4 ** Contact: http://www.qt.io/licensing/
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 The Qt Company. For licensing terms
14 ** and conditions see http://www.qt.io/terms-conditions. For further
15 ** information use the contact form at http://www.qt.io/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 or version 3 as published by the Free
20 ** Software Foundation and appearing in the file LICENSE.LGPLv21 and
21 ** LICENSE.LGPLv3 included in the packaging of this file. Please review the
22 ** following information to ensure the GNU Lesser General Public License
23 ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
24 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
25 **
26 ** As a special exception, The Qt Company gives you certain additional
27 ** rights. These rights are described in The Qt Company LGPL Exception
28 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
29 **
30 ** GNU General Public License Usage
31 ** Alternatively, this file may be used under the terms of the GNU
32 ** General Public License version 3.0 as published by the Free Software
33 ** Foundation and appearing in the file LICENSE.GPL included in the
34 ** packaging of this file. Please review the following information to
35 ** ensure the GNU General Public License version 3.0 requirements will be
36 ** met: http://www.gnu.org/copyleft/gpl.html.
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41
42
43 #include <QtTest/QtTest>
44 #include <qcoreapplication.h>
45 #include <qstring.h>
46 #include <qtemporaryfile.h>
47 #include <qfile.h>
48 #include <qdir.h>
49 #include <qset.h>
50
51 #if defined(Q_OS_WIN)
52 # include <windows.h>
53 #endif
54 #if defined(Q_OS_UNIX)
55 # include <sys/types.h>
56 # include <sys/stat.h>
57 # include <errno.h>
58 # include <fcntl.h> // open(2)
59 # include <unistd.h> // close(2)
60 #endif
61
62 #ifdef Q_OS_SYMBIAN
63 #define SRCDIR ""
64 #endif
65
66 //TESTED_CLASS=
67 //TESTED_FILES=
68
69 class tst_QTemporaryFile : public QObject
70 {
71 Q_OBJECT
72 public slots:
73 void initTestCase();
74 void cleanupTestCase();
75
76 private slots:
77 void construction();
78 void fileTemplate();
79 void fileTemplate_data();
80 void getSetCheck();
81 void fileName();
82 void fileNameIsEmpty();
83 void autoRemove();
84 void write();
85 void openCloseOpenClose();
86 void size();
87 void resize();
88 void openOnRootDrives();
89 void stressTest();
90 void rename();
91 void renameFdLeak();
92 void reOpenThroughQFile();
93 void keepOpenMode();
94 void resetTemplateAfterError();
95 void setTemplateAfterOpen();
96 void autoRemoveAfterFailedRename();
97 };
98
initTestCase()99 void tst_QTemporaryFile::initTestCase()
100 {
101 // For fileTemplate tests
102 QVERIFY(QDir("test-XXXXXX").exists() || QDir().mkdir("test-XXXXXX"));
103 }
104
cleanupTestCase()105 void tst_QTemporaryFile::cleanupTestCase()
106 {
107 // From fileTemplate tests
108 QVERIFY(QDir().rmdir("test-XXXXXX"));
109 }
110
construction()111 void tst_QTemporaryFile::construction()
112 {
113 QTemporaryFile file(0);
114 QString tmp = QDir::tempPath();
115 QCOMPARE(file.fileTemplate().left(tmp.size()), tmp);
116 QCOMPARE(file.fileTemplate().at(tmp.size()), QChar('/'));
117 }
118
119 // Testing get/set functions
getSetCheck()120 void tst_QTemporaryFile::getSetCheck()
121 {
122 QTemporaryFile obj1;
123 // bool QTemporaryFile::autoRemove()
124 // void QTemporaryFile::setAutoRemove(bool)
125 obj1.setAutoRemove(false);
126 QCOMPARE(false, obj1.autoRemove());
127 obj1.setAutoRemove(true);
128 QCOMPARE(true, obj1.autoRemove());
129 }
130
131 /*
132 This tests whether the temporary file really gets placed in QDir::tempPath
133 */
fileName()134 void tst_QTemporaryFile::fileName()
135 {
136 // Get QDir::tempPath and make an absolute path.
137 QString tempPath = QDir::tempPath();
138 QString absoluteTempPath = QDir(tempPath).absolutePath();
139 QTemporaryFile file;
140 file.setAutoRemove(true);
141 file.open();
142 QString fileName = file.fileName();
143 QVERIFY(QFile::exists(fileName));
144 // Get path to the temp file, whithout the file name.
145 QString absoluteFilePath = QFileInfo(fileName).absolutePath();
146 #if defined(Q_OS_WIN) || defined(Q_OS_SYMBIAN)
147 absoluteFilePath = absoluteFilePath.toLower();
148 absoluteTempPath = absoluteTempPath.toLower();
149 #endif
150 QCOMPARE(absoluteFilePath, absoluteTempPath);
151 }
152
fileNameIsEmpty()153 void tst_QTemporaryFile::fileNameIsEmpty()
154 {
155 QString filename;
156 {
157 QTemporaryFile file;
158 QVERIFY(file.fileName().isEmpty());
159
160 QVERIFY(file.open());
161 QVERIFY(!file.fileName().isEmpty());
162
163 filename = file.fileName();
164 QVERIFY(QFile::exists(filename));
165
166 file.close();
167 QVERIFY(!file.isOpen());
168 QVERIFY(QFile::exists(filename));
169 QVERIFY(!file.fileName().isEmpty());
170 }
171 QVERIFY(!QFile::exists(filename));
172 }
173
autoRemove()174 void tst_QTemporaryFile::autoRemove()
175 {
176 // Test auto remove
177 QString fileName;
178 {
179 QTemporaryFile file("tempXXXXXX");
180 file.setAutoRemove(true);
181 QVERIFY(file.open());
182 fileName = file.fileName();
183 file.close();
184 }
185 QVERIFY(!QFile::exists(fileName));
186
187 // Test if disabling auto remove works.
188 {
189 QTemporaryFile file("tempXXXXXX");
190 file.setAutoRemove(false);
191 QVERIFY(file.open());
192 fileName = file.fileName();
193 file.close();
194 }
195 QVERIFY(QFile::exists(fileName));
196 QVERIFY(QFile::remove(fileName));
197
198
199 // Do not explicitly call setAutoRemove (tests if it really is the default as documented)
200 {
201 QTemporaryFile file("tempXXXXXX");
202 QVERIFY(file.open());
203 fileName = file.fileName();
204 file.close();
205 }
206 QVERIFY(!QFile::exists(fileName));
207
208 }
209
write()210 void tst_QTemporaryFile::write()
211 {
212 QByteArray data("OLE\nOLE\nOLE");
213 QTemporaryFile file;
214 QVERIFY(file.open());
215 QCOMPARE((int)file.write(data), data.size());
216 file.reset();
217 QFile compare(file.fileName());
218 compare.open(QIODevice::ReadOnly);
219 QCOMPARE(compare.readAll() , data);
220 file.close();
221 }
222
openCloseOpenClose()223 void tst_QTemporaryFile::openCloseOpenClose()
224 {
225 QString fileName;
226 {
227 // Create a temp file
228 QTemporaryFile file("tempXXXXXX");
229 file.setAutoRemove(true);
230 QVERIFY(file.open());
231 file.write("OLE");
232 fileName = file.fileName();
233 QVERIFY(QFile::exists(fileName));
234 file.close();
235
236 // Check that it still exists after being closed
237 QVERIFY(QFile::exists(fileName));
238 QVERIFY(!file.isOpen());
239 QVERIFY(file.open());
240 QCOMPARE(file.readAll(), QByteArray("OLE"));
241 // Check that it's still the same file after being opened again.
242 QCOMPARE(file.fileName(), fileName);
243 }
244 QVERIFY(!QFile::exists(fileName));
245 }
246
size()247 void tst_QTemporaryFile::size()
248 {
249 QTemporaryFile file;
250 QVERIFY(file.open());
251 QVERIFY(file.exists());
252 QVERIFY(!file.isSequential());
253 QByteArray str("foobar");
254 file.write(str);
255 QVERIFY(QFile::exists(file.fileName()));
256 // On CE it takes more time for the filesystem to update
257 // the information. Usually you have to close it or seek
258 // to get latest information. flush() does not help either.
259 #if !defined(Q_OS_WINCE)
260 QCOMPARE(file.size(), qint64(6));
261 #endif
262 file.seek(0);
263 QCOMPARE(file.size(), qint64(6));
264 }
265
resize()266 void tst_QTemporaryFile::resize()
267 {
268 QTemporaryFile file;
269 file.setAutoRemove(true);
270 QVERIFY(file.open());
271 QVERIFY(file.resize(100));
272
273 QCOMPARE(QFileInfo(file.fileName()).size(), qint64(100));
274
275 file.close();
276 }
277
openOnRootDrives()278 void tst_QTemporaryFile::openOnRootDrives()
279 {
280 #if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
281 unsigned int lastErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
282 #endif
283 // If it's possible to create a file in the root directory, it
284 // must be possible to create a temp file there too.
285 foreach (QFileInfo driveInfo, QDir::drives()) {
286 QFile testFile(driveInfo.filePath() + "XXXXXX.txt");
287 if (testFile.open(QIODevice::ReadWrite)) {
288 testFile.remove();
289 QTemporaryFile file(driveInfo.filePath() + "XXXXXX.txt");
290 file.setAutoRemove(true);
291 QVERIFY(file.open());
292 }
293 }
294 #if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
295 SetErrorMode(lastErrorMode);
296 #endif
297 }
298
stressTest()299 void tst_QTemporaryFile::stressTest()
300 {
301 #if defined(Q_OS_WINCE) || defined(Q_OS_SYMBIAN)
302 // 200 is still ok, first colision happens after ~30
303 const int iterations = 200;
304 #else
305 const int iterations = 1000;
306 #endif
307
308 QSet<QString> names;
309 for (int i = 0; i < iterations; ++i) {
310 QTemporaryFile file;
311 file.setAutoRemove(false);
312 QVERIFY2(file.open(), qPrintable(file.errorString()));
313 QVERIFY(!names.contains(file.fileName()));
314 names.insert(file.fileName());
315 }
316 for (QSet<QString>::const_iterator it = names.constBegin(); it != names.constEnd(); ++it) {
317 QFile::remove(*it);
318 }
319 }
320
rename()321 void tst_QTemporaryFile::rename()
322 {
323 // This test checks that the temporary file is deleted, even after a
324 // rename.
325
326 QDir dir;
327 QVERIFY(!dir.exists("temporary-file.txt"));
328
329 QString tempname;
330 {
331 QTemporaryFile file(dir.filePath("temporary-file.XXXXXX"));
332
333 QVERIFY2(file.open(), qPrintable(file.errorString()));
334 tempname = file.fileName();
335 QVERIFY(dir.exists(tempname));
336
337 QVERIFY2(file.rename("temporary-file.txt"), qPrintable(file.errorString()));
338 QVERIFY(!dir.exists(tempname));
339 QVERIFY(dir.exists("temporary-file.txt"));
340 QCOMPARE(file.fileName(), QString("temporary-file.txt"));
341 }
342
343 QVERIFY(!dir.exists(tempname));
344 QVERIFY(!dir.exists("temporary-file.txt"));
345 }
346
renameFdLeak()347 void tst_QTemporaryFile::renameFdLeak()
348 {
349 #ifdef Q_OS_UNIX
350 // Test this on Unix only
351
352 // Open a bunch of files to force the fd count to go up
353 static const int count = 10;
354 int bunch_of_files[count];
355 for (int i = 0; i < count; ++i) {
356 bunch_of_files[i] = ::open(SRCDIR "tst_qtemporaryfile.cpp", O_RDONLY);
357 QVERIFY(bunch_of_files[i] != -1);
358 }
359
360 int fd;
361 {
362 QTemporaryFile file;
363 file.setAutoRemove(false);
364 QVERIFY(file.open());
365
366 // close the bunch of files
367 for (int i = 0; i < count; ++i)
368 ::close(bunch_of_files[i]);
369
370 // save the file descriptor for later
371 fd = file.handle();
372
373 // rename the file to something
374 QString newPath = QDir::tempPath() + "/tst_qtemporaryfile-renameFdLeak-" + QString::number(getpid());
375 file.rename(newPath);
376 QFile::remove(newPath);
377 }
378
379 // check if QTemporaryFile closed the file
380 QVERIFY(::close(fd) == -1 && errno == EBADF);
381 #endif
382 }
383
reOpenThroughQFile()384 void tst_QTemporaryFile::reOpenThroughQFile()
385 {
386 QByteArray data("abcdefghij");
387
388 QTemporaryFile file;
389 QVERIFY(((QFile &)file).open(QIODevice::WriteOnly));
390 QCOMPARE(file.write(data), (qint64)data.size());
391
392 file.close();
393 QVERIFY(file.open());
394 QCOMPARE(file.readAll(), data);
395 }
396
keepOpenMode()397 void tst_QTemporaryFile::keepOpenMode()
398 {
399 QByteArray data("abcdefghij");
400
401 {
402 QTemporaryFile file;
403 QVERIFY(((QFile &)file).open(QIODevice::WriteOnly));
404 QVERIFY(QIODevice::WriteOnly == file.openMode());
405
406 QCOMPARE(file.write(data), (qint64)data.size());
407 file.close();
408
409 QVERIFY(((QFile &)file).open(QIODevice::ReadOnly));
410 QVERIFY(QIODevice::ReadOnly == file.openMode());
411 QCOMPARE(file.readAll(), data);
412 }
413
414 {
415 QTemporaryFile file;
416 QVERIFY(file.open());
417 QCOMPARE(file.write(data), (qint64)data.size());
418 QVERIFY(file.rename("temporary-file.txt"));
419
420 QVERIFY(((QFile &)file).open(QIODevice::ReadOnly));
421 QVERIFY(QIODevice::ReadOnly == file.openMode());
422 QCOMPARE(file.readAll(), data);
423
424 QVERIFY(((QFile &)file).open(QIODevice::WriteOnly));
425 QVERIFY(QIODevice::WriteOnly == file.openMode());
426 }
427 }
428
resetTemplateAfterError()429 void tst_QTemporaryFile::resetTemplateAfterError()
430 {
431 // calling setFileTemplate on a failed open
432
433 QString tempPath = QDir::tempPath();
434
435 QString const fileTemplate("destination/qt_temp_file_test.XXXXXX");
436 QString const fileTemplate2(tempPath + "/qt_temp_file_test.XXXXXX");
437
438 QVERIFY2( QDir(tempPath).exists() || QDir().mkpath(tempPath), "Test precondition" );
439 QVERIFY2( !QFile::exists("destination"), "Test precondition" );
440 QVERIFY2( !QFile::exists(fileTemplate2) || QFile::remove(fileTemplate2), "Test precondition" );
441
442 QFile file(fileTemplate2);
443 QByteArray fileContent("This file is intentionally NOT left empty.");
444
445 QVERIFY( file.open(QIODevice::ReadWrite | QIODevice::Truncate) );
446 QCOMPARE( file.write(fileContent), (qint64)fileContent.size() );
447 QVERIFY( file.flush() );
448
449 QString fileName;
450 {
451 QTemporaryFile temp;
452
453 QVERIFY( temp.fileName().isEmpty() );
454 QVERIFY( !temp.fileTemplate().isEmpty() );
455
456 temp.setFileTemplate( fileTemplate );
457
458 QVERIFY( temp.fileName().isEmpty() );
459 QCOMPARE( temp.fileTemplate(), fileTemplate );
460
461 QVERIFY( !temp.open() );
462
463 QVERIFY( temp.fileName().isEmpty() );
464 QCOMPARE( temp.fileTemplate(), fileTemplate );
465
466 temp.setFileTemplate( fileTemplate2 );
467 QVERIFY( temp.open() );
468
469 fileName = temp.fileName();
470 QVERIFY( QFile::exists(fileName) );
471 QVERIFY( !fileName.isEmpty() );
472 QVERIFY2( fileName != fileTemplate2,
473 ("Generated name shouldn't be same as template: " + fileTemplate2).toLocal8Bit().constData() );
474 }
475
476 QVERIFY( !QFile::exists(fileName) );
477
478 file.seek(0);
479 QCOMPARE( QString(file.readAll()), QString(fileContent) );
480 QVERIFY( file.remove() );
481 }
482
setTemplateAfterOpen()483 void tst_QTemporaryFile::setTemplateAfterOpen()
484 {
485 QTemporaryFile temp;
486
487 QVERIFY( temp.fileName().isEmpty() );
488 QVERIFY( !temp.fileTemplate().isEmpty() );
489
490 QVERIFY( temp.open() );
491
492 QString const fileName = temp.fileName();
493 QString const newTemplate("funny-path/funny-name-XXXXXX.tmp");
494
495 QVERIFY( !fileName.isEmpty() );
496 QVERIFY( QFile::exists(fileName) );
497 QVERIFY( !temp.fileTemplate().isEmpty() );
498 QVERIFY( temp.fileTemplate() != newTemplate );
499
500 temp.close(); // QTemporaryFile::setFileTemplate will assert on isOpen() up to 4.5.2
501 temp.setFileTemplate(newTemplate);
502 QCOMPARE( temp.fileTemplate(), newTemplate );
503
504 QVERIFY( temp.open() );
505 QCOMPARE( temp.fileName(), fileName );
506 QCOMPARE( temp.fileTemplate(), newTemplate );
507 }
508
autoRemoveAfterFailedRename()509 void tst_QTemporaryFile::autoRemoveAfterFailedRename()
510 {
511 struct CleanOnReturn
512 {
513 ~CleanOnReturn()
514 {
515 if (!tempName.isEmpty())
516 QFile::remove(tempName);
517 }
518
519 void reset()
520 {
521 tempName.clear();
522 }
523
524 QString tempName;
525 };
526
527 CleanOnReturn cleaner;
528
529 {
530 QTemporaryFile file;
531 QVERIFY( file.open() );
532 cleaner.tempName = file.fileName();
533
534 QVERIFY( QFile::exists(cleaner.tempName) );
535 QVERIFY( !QFileInfo("i-do-not-exist").isDir() );
536 QVERIFY( !file.rename("i-do-not-exist/file.txt") );
537 QVERIFY( QFile::exists(cleaner.tempName) );
538 }
539
540 QVERIFY( !QFile::exists(cleaner.tempName) );
541 cleaner.reset();
542 }
543
fileTemplate_data()544 void tst_QTemporaryFile::fileTemplate_data()
545 {
546 QTest::addColumn<QString>("prefix");
547 QTest::addColumn<QString>("suffix");
548 QTest::addColumn<bool>("openResult");
549
550 QString unicode = QString::fromUtf8("\xc3\xa5\xc3\xa6\xc3\xb8");
551
552 QTest::newRow("<empty>") << QString() << QString() << true;
553
554 QTest::newRow(".") << QString(".") << QString() << true;
555 QTest::newRow("..") << QString("..") << QString() << true;
556
557 QTest::newRow("foo") << QString("foo") << QString() << true;
558 QTest::newRow("qt_ ... xxxxxx") << QString("qt_") << QString("xxxxxx") << true;
559 QTest::newRow("qt_ ... xxx") << QString("qt_") << QString("xxx") << true;
560 QTest::newRow("qt_ ... xXx") << QString("qt_") << QString("xXx") << true;
561 QTest::newRow("qt_ ...") << QString("qt_") << QString() << true;
562 QTest::newRow("qt_ ... _XXXX") << QString("qt_") << QString("_XXXX") << true;
563 QTest::newRow("qt_ ... _XXXXX") << QString("qt_") << QString("_XXXXX") << true;
564 QTest::newRow("qt_XXXX_ ...") << QString("qt_XXXX_") << QString() << true;
565 QTest::newRow("qt_XXXXX_ ...") << QString("qt_XXXXX_") << QString() << true;
566 QTest::newRow("qt_XXXX_ ... _XXXX") << QString("qt_XXXX_") << QString("_XXXX") << true;
567 QTest::newRow("qt_XXXXX_ ... _XXXXX") << QString("qt_XXXXX_") << QString("_XXXXX") << true;
568
569 QTest::newRow("blaXXXXXX") << QString("bla") << QString() << true;
570 QTest::newRow("XXXXXXbla") << QString() << QString("bla") << true;
571
572 QTest::newRow("does-not-exist/qt_temp.XXXXXX") << QString("does-not-exist/qt_temp") << QString() << false;
573
574 QTest::newRow("XXXXXX<unicode>") << QString() << unicode << true;
575 QTest::newRow("<unicode>XXXXXX") << unicode << QString() << true;
576 QTest::newRow("<unicode>XXXXXX<unicode>") << unicode << unicode << true;
577 }
578
fileTemplate()579 void tst_QTemporaryFile::fileTemplate()
580 {
581 QVERIFY(QDir("test-XXXXXX").exists());
582
583 struct CleanOnReturn
584 {
585 ~CleanOnReturn()
586 {
587 Q_FOREACH(QString tempName, tempNames)
588 QFile::remove(tempName);
589 }
590
591 void reset()
592 {
593 tempNames.clear();
594 }
595
596 QStringList tempNames;
597 };
598
599 CleanOnReturn cleaner;
600
601 QFETCH(QString, prefix);
602 QFETCH(QString, suffix);
603 QFETCH(bool, openResult);
604
605 enum IterationType {
606 UseConstructor,
607 UseSetFileTemplate,
608 Done
609 };
610
611 for (IterationType setFileTemplate = UseConstructor; setFileTemplate != Done;
612 setFileTemplate = IterationType(int(setFileTemplate) + 1))
613 {
614 Q_FOREACH(QString const &tempName, cleaner.tempNames)
615 QVERIFY( !QFile::exists(tempName) );
616
617 cleaner.reset();
618
619 QString fileTemplate1 = prefix + QString("XX") + suffix;
620 QString fileTemplate2 = prefix + QString("XXXX") + suffix;
621 QString fileTemplate3 = prefix + QString("XXXXXX") + suffix;
622 QString fileTemplate4 = prefix + QString("XXXXXXXX") + suffix;
623
624 QTemporaryFile file1(setFileTemplate ? QString() : fileTemplate1);
625 QTemporaryFile file2(setFileTemplate ? QString() : fileTemplate2);
626 QTemporaryFile file3(setFileTemplate ? QString() : fileTemplate3);
627 QTemporaryFile file4(setFileTemplate ? QString() : fileTemplate4);
628 QTemporaryFile file5(setFileTemplate ? QString() : "test-XXXXXX/" + fileTemplate1);
629 QTemporaryFile file6(setFileTemplate ? QString() : "test-XXXXXX/" + fileTemplate3);
630
631 if (setFileTemplate) {
632 file1.setFileTemplate(fileTemplate1);
633 file2.setFileTemplate(fileTemplate2);
634 file3.setFileTemplate(fileTemplate3);
635 file4.setFileTemplate(fileTemplate4);
636 file5.setFileTemplate("test-XXXXXX/" + fileTemplate1);
637 file6.setFileTemplate("test-XXXXXX/" + fileTemplate3);
638 }
639
640 if (openResult) {
641 QVERIFY2(file1.open(), qPrintable(file1.errorString()));
642 QVERIFY2(file2.open(), qPrintable(file2.errorString()));
643 QVERIFY2(file3.open(), qPrintable(file3.errorString()));
644 QVERIFY2(file4.open(), qPrintable(file4.errorString()));
645 QVERIFY2(file5.open(), qPrintable(file5.errorString()));
646 QVERIFY2(file6.open(), qPrintable(file6.errorString()));
647 } else {
648 QVERIFY(!file1.open());
649 QVERIFY(!file2.open());
650 QVERIFY(!file3.open());
651 QVERIFY(!file4.open());
652 QVERIFY(!file5.open());
653 QVERIFY(!file6.open());
654 }
655
656 QCOMPARE(file1.exists(), openResult);
657 QCOMPARE(file2.exists(), openResult);
658 QCOMPARE(file3.exists(), openResult);
659 QCOMPARE(file4.exists(), openResult);
660 QCOMPARE(file5.exists(), openResult);
661 QCOMPARE(file6.exists(), openResult);
662
663 // make sure the file exists under the *correct* name
664 if (openResult) {
665 cleaner.tempNames << file1.fileName()
666 << file2.fileName()
667 << file3.fileName()
668 << file4.fileName()
669 << file5.fileName()
670 << file6.fileName();
671
672 QDir currentDir;
673 QString fileName1 = currentDir.relativeFilePath(file1.fileName());
674 QString fileName2 = currentDir.relativeFilePath(file2.fileName());
675 QString fileName3 = currentDir.relativeFilePath(file3.fileName());
676 QString fileName4 = currentDir.relativeFilePath(file4.fileName());
677 QString fileName5 = currentDir.relativeFilePath(file5.fileName());
678 QString fileName6 = currentDir.relativeFilePath(file6.fileName());
679
680 QVERIFY2(fileName1.startsWith(fileTemplate1 + QLatin1Char('.')), qPrintable(file1.fileName()));
681 QVERIFY2(fileName2.startsWith(fileTemplate2 + QLatin1Char('.')), qPrintable(file2.fileName()));
682 QVERIFY2(fileName5.startsWith("test-XXXXXX/" + fileTemplate1 + QLatin1Char('.')), qPrintable(file5.fileName()));
683 QVERIFY2(fileName6.startsWith("test-XXXXXX/" + prefix), qPrintable(file6.fileName()));
684
685 if (!prefix.isEmpty()) {
686 QVERIFY2(fileName3.startsWith(prefix), qPrintable(file3.fileName()));
687 QVERIFY2(fileName4.startsWith(prefix), qPrintable(file4.fileName()));
688 }
689
690 if (!suffix.isEmpty()) {
691 QVERIFY2(fileName3.endsWith(suffix), qPrintable(file3.fileName()));
692 QVERIFY2(fileName4.endsWith(suffix), qPrintable(file4.fileName()));
693 QVERIFY2(fileName6.endsWith(suffix), qPrintable(file6.fileName()));
694 }
695 }
696 }
697 }
698
699 QTEST_MAIN(tst_QTemporaryFile)
700 #include "tst_qtemporaryfile.moc"
701