qt-everywhere-src-5.14.1/qtbase/tests/auto/tools/qmakelib/tst_qmakelib.cpp - orbit - Git at Google

 /****************************************************************************
 **
 ** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the test suite of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:GPL-EXCEPT$
 ** Commercial License Usage
 ** Licensees holding valid commercial Qt licenses may use this file in
 ** accordance with the commercial license agreement provided with the
 ** Software or, alternatively, in accordance with the terms contained in
 ** a written agreement between you and The Qt Company. For licensing terms
 ** and conditions see https://www.qt.io/terms-conditions. For further
 ** information use the contact form at https://www.qt.io/contact-us.
 **
 ** GNU General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU
 ** General Public License version 3 as published by the Free Software
 ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
 ** included in the packaging of this file. Please review the following
 ** information to ensure the GNU General Public License requirements will
 ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
 **
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/

 #include "tst_qmakelib.h"

 #include <ioutils.h>

 using namespace QMakeInternal;

 void tst_qmakelib::initTestCase()
 {
     m_indir = QFINDTESTDATA("testdata");
     m_outdir = m_indir + QLatin1String("_build");
     m_env.insert(QStringLiteral("E1"), QStringLiteral("env var"));
 #ifdef Q_OS_WIN
     m_env.insert(QStringLiteral("COMSPEC"), qgetenv("COMSPEC"));
 #endif
     m_prop.insert(ProKey("P1"), ProString("prop val"));
     m_prop.insert(ProKey("QT_HOST_DATA/get"), ProString(m_indir));
     m_prop.insert(ProKey("QT_HOST_DATA/src"), ProString(m_indir));

     QVERIFY(!m_indir.isEmpty());
     QVERIFY(QDir(m_outdir).removeRecursively());
     QVERIFY(QDir().mkpath(m_outdir));
 }

 void tst_qmakelib::cleanupTestCase()
 {
     QVERIFY(QDir(m_outdir).removeRecursively());
 }

 void tst_qmakelib::proString()
 {
     QString qs1(QStringLiteral("this is a string"));

     ProString s1(qs1);
     QCOMPARE(s1.toQString(), QStringLiteral("this is a string"));

     ProString s2(qs1, 5, 8);
     QCOMPARE(s2.toQString(), QStringLiteral("is a str"));

     QCOMPARE(s2.hash(), 0x80000000);
     qHash(s2);
     QCOMPARE(s2.hash(), 90404018U);

     QCOMPARE(s2.mid(0, 10).toQString(), QStringLiteral("is a str"));
     QCOMPARE(s2.mid(1, 5).toQString(), QStringLiteral("s a s"));
     QCOMPARE(s2.mid(10, 3).toQString(), QStringLiteral(""));

     QString qs2(QStringLiteral("   spacy  string   "));
     QCOMPARE(ProString(qs2, 3, 13).trimmed().toQString(), QStringLiteral("spacy  string"));
     QCOMPARE(ProString(qs2, 1, 17).trimmed().toQString(), QStringLiteral("spacy  string"));

     QVERIFY(s2.toQStringRef().string()->isSharedWith(qs1));
     s2.prepend(ProString("there "));
     QCOMPARE(s2.toQString(), QStringLiteral("there is a str"));
     QVERIFY(!s2.toQStringRef().string()->isSharedWith(qs1));

     ProString s3("this is a longish string with bells and whistles");
     s3 = s3.mid(18, 17);
     // Prepend to detached string with lots of spare space in it.
     s3.prepend(ProString("another "));
     QCOMPARE(s3.toQString(), QStringLiteral("another string with bells"));

     // Note: The string still has plenty of spare space.
     s3.append(QLatin1Char('.'));
     QCOMPARE(s3.toQString(), QStringLiteral("another string with bells."));
     s3.append(QLatin1String(" eh?"));
     QCOMPARE(s3.toQString(), QStringLiteral("another string with bells. eh?"));

     s3.append(ProString(" yeah!"));
     QCOMPARE(s3.toQString(), QStringLiteral("another string with bells. eh? yeah!"));

     bool pending = false; // Not in string, but joining => add space
     s3.append(ProString("..."), &pending);
     QCOMPARE(s3.toQString(), QStringLiteral("another string with bells. eh? yeah! ..."));
     QVERIFY(pending);

     ProStringList sl1;
     sl1 << ProString("") << ProString("foo") << ProString("barbaz");
     ProString s4a("hallo");
     s4a.append(sl1);
     QCOMPARE(s4a.toQString(), QStringLiteral("hallo foo barbaz"));
     ProString s4b("hallo");
     pending = false;
     s4b.append(sl1, &pending);
     QCOMPARE(s4b.toQString(), QStringLiteral("hallo  foo barbaz"));
     ProString s4c;
     pending = false;
     s4c.append(sl1, &pending);
     QCOMPARE(s4c.toQString(), QStringLiteral(" foo barbaz"));
     // bizarreness
     ProString s4d("hallo");
     pending = false;
     s4d.append(sl1, &pending, true);
     QCOMPARE(s4d.toQString(), QStringLiteral("hallo foo barbaz"));
     ProString s4e;
     pending = false;
     s4e.append(sl1, &pending, true);
     QCOMPARE(s4e.toQString(), QStringLiteral("foo barbaz"));

     ProStringList sl2;
     sl2 << ProString("foo");
     ProString s5;
     s5.append(sl2);
     QCOMPARE(s5.toQString(), QStringLiteral("foo"));
     QVERIFY(s5.toQStringRef().string()->isSharedWith(*sl2.first().toQStringRef().string()));

     QCOMPARE(ProString("one") + ProString(" more"), QStringLiteral("one more"));
 }

 void tst_qmakelib::proStringList()
 {
     ProStringList sl1;
     sl1 << ProString("qt") << ProString(QLatin1String("is"))
         << ProString(QStringLiteral("uncool")).mid(2);

     QCOMPARE(sl1.toQStringList(), QStringList() << "qt" << "is" << "cool");
     QCOMPARE(sl1.join(QStringLiteral("~~")), QStringLiteral("qt~~is~~cool"));

     ProStringList sl2;
     sl2 << ProString("mostly") << ProString("...") << ProString("is") << ProString("...");
     sl1.insertUnique(sl2);
     QCOMPARE(sl1.toQStringList(), QStringList() << "qt" << "is" << "cool" << "mostly" << "...");

     QVERIFY(sl1.contains("cool"));
     QVERIFY(!sl1.contains("COOL"));
     QVERIFY(sl1.contains("COOL", Qt::CaseInsensitive));
 }

 void tst_qmakelib::quoteArgUnix_data()
 {
     QTest::addColumn<QString>("in");
     QTest::addColumn<QString>("out");

     static const struct {
         const char * const in;
         const char * const out;
     } vals[] = {
         { "", "''" },
         { "hallo", "hallo" },
         { "hallo du", "'hallo du'" },
         { "ha'llo", "'ha'\\''llo'" },
     };

     for (unsigned i = 0; i < sizeof(vals)/sizeof(vals[0]); i++)
         QTest::newRow(vals[i].in) << QString::fromLatin1(vals[i].in)
                                   << QString::fromLatin1(vals[i].out);
 }

 void tst_qmakelib::quoteArgUnix()
 {
     QFETCH(QString, in);
     QFETCH(QString, out);

     QCOMPARE(IoUtils::shellQuoteUnix(in), out);
 }

 void tst_qmakelib::quoteArgWin_data()
 {
     QTest::addColumn<QString>("in");
     QTest::addColumn<QString>("out");

     static const struct {
         const char * const in;
         const char * const out;
     } vals[] = {
         { "", "\"\"" },
         { "hallo", "hallo" },
         { "hallo du", "\"hallo du\"" },
         { "hallo\\", "hallo\\" },
         { "hallo du\\", "\"hallo du\\\\\"" },
         { "ha\"llo", "\"ha\\\"llo^\"" },
         { "ha\\\"llo", "\"ha\\\\\\\"llo^\"" },
     };

     for (unsigned i = 0; i < sizeof(vals)/sizeof(vals[0]); i++)
         QTest::newRow(vals[i].in) << QString::fromLatin1(vals[i].in)
                                   << QString::fromLatin1(vals[i].out);
 }

 void tst_qmakelib::quoteArgWin()
 {
     QFETCH(QString, in);
     QFETCH(QString, out);

     QCOMPARE(IoUtils::shellQuoteWin(in), out);
 }

 void tst_qmakelib::pathUtils()
 {
     QString afp = QCoreApplication::applicationFilePath();
     QVERIFY(IoUtils::exists(afp));
     QVERIFY(!IoUtils::exists(afp + "-tehfail"));
     QCOMPARE(IoUtils::fileType(afp), IoUtils::FileIsRegular);
     QString adp = QCoreApplication::applicationDirPath();
     QCOMPARE(IoUtils::fileType(adp), IoUtils::FileIsDir);

     QString fn0 = "file/path";
     QVERIFY(IoUtils::isRelativePath(fn0));

     QString fn1 = "/a/unix/file/path";
     QCOMPARE(IoUtils::pathName(fn1).toString(), QStringLiteral("/a/unix/file/"));
     QCOMPARE(IoUtils::fileName(fn1).toString(), QStringLiteral("path"));
 }

 void tst_qmakelib::ioUtilRelativity_data()
 {
     QTest::addColumn<QString>("path");
     QTest::addColumn<bool>("relative");

     static const struct {
         const char *name;
         const char *path;
         bool relative;
     } rows[] = {
         { "resource", ":/resource",
 #ifdef QMAKE_BUILTIN_PRFS
           false
 #else
           true
 #endif
         },
 #ifdef Q_OS_WIN // all the complications:
         // (except UNC: unsupported)
         { "drive-abs", "c:/path/to/file", false },
         { "drive-abs-bs", "c:\\path\\to\\file", false },
         { "drive-path", "c:path/to/file.txt", true },
         { "drive-path-bs", "c:path\\to\\file.txt", true },
         { "rooted", "/Users/qt/bin/true", true },
         { "rooted-bs", "\\Users\\qt\\bin\\true", true },
         { "drive-rel", "c:file.txt", true },
         { "subdir-bs", "path\\to\\file", true },
 #else
         { "rooted", "/usr/bin/false", false },
 #endif // Q_OS_WIN
         { "subdir", "path/to/file", true },
         { "simple", "file.name", true },
         { "empty", "", true }
     };

     for (unsigned int i = sizeof(rows) / sizeof(rows[0]); i-- > 0; )
         QTest::newRow(rows[i].name) << QString::fromLatin1(rows[i].path)
                                     << rows[i].relative;
 }

 void tst_qmakelib::ioUtilRelativity()
 {
     QFETCH(QString, path);
     QFETCH(bool, relative);

     QCOMPARE(IoUtils::isRelativePath(path), relative);
 }

 void tst_qmakelib::ioUtilResolve_data()
 {
     QTest::addColumn<QString>("base");
     QTest::addColumn<QString>("path");
     QTest::addColumn<QString>("expect");

     static const struct {
         const char *name;
         const char *base;
         const char *path;
         const char *expect;
     } data[] = {
 #ifdef Q_OS_WIN // all the complications:
         { "drive-drive", "a:/ms/dir", "z:/root/file", "z:/root/file" },
         { "drive-drive-bs", "a:\\ms\\dir", "z:\\root\\file", "z:/root/file" },
         { "drive-root", "a:/ms/dir", "/root/file", "a:/root/file" },
         { "drive-root-bs", "a:\\ms\\dir", "\\root\\file", "a:/root/file" },
         { "drive-sub", "a:/ms/dir", "sub/file", "a:/ms/dir/sub/file" },
         { "drive-sub-bs", "a:\\ms\\dir", "sub\\file", "a:/ms/dir/sub/file" },
         { "drive-rel", "a:/ms/dir", "file.txt", "a:/ms/dir/file.txt" },
         { "drive-rel-bs", "a:\\ms\\dir", "file.txt", "a:/ms/dir/file.txt" },
 #else
         { "abs-abs", "/a/unix/dir", "/root/file", "/root/file" },
         { "abs-sub", "/a/unix/dir", "sub/file", "/a/unix/dir/sub/file" },
         { "abs-rel", "/a/unix/dir", "file.txt", "/a/unix/dir/file.txt" },
 #endif // Q_OS_WIN
     };

     for (unsigned i = sizeof(data) / sizeof(data[0]); i-- > 0; )
         QTest::newRow(data[i].name) << QString::fromLatin1(data[i].base)
                                     << QString::fromLatin1(data[i].path)
                                     << QString::fromLatin1(data[i].expect);
 }

 void tst_qmakelib::ioUtilResolve()
 {
     QFETCH(QString, base);
     QFETCH(QString, path);
     QFETCH(QString, expect);

     QCOMPARE(IoUtils::resolvePath(base, path), expect);
 }

 void QMakeTestHandler::print(const QString &fileName, int lineNo, int type, const QString &msg)
 {
     QString pfx = ((type & QMakeParserHandler::CategoryMask) == QMakeParserHandler::WarningMessage)
                   ? QString::fromLatin1("WARNING: ") : QString();
     if (lineNo)
         doPrint(QStringLiteral("%1%2:%3: %4").arg(pfx, fileName, QString::number(lineNo), msg));
     else
         doPrint(QStringLiteral("%1%2").arg(pfx, msg));
 }

 void QMakeTestHandler::doPrint(const QString &msg)
 {
     if (!expected.isEmpty() && expected.first() == msg) {
         expected.removeAt(0);
     } else {
         qWarning("%s", qPrintable(msg));
         printed = true;
     }
 }

 QTEST_MAIN(tst_qmakelib)
	/****************************************************************************
	**
	** Copyright (C) 2016 The Qt Company Ltd.
	** Contact: https://www.qt.io/licensing/
	**
	** This file is part of the test suite of the Qt Toolkit.
	**
	** $QT_BEGIN_LICENSE:GPL-EXCEPT$
	** Commercial License Usage
	** Licensees holding valid commercial Qt licenses may use this file in
	** accordance with the commercial license agreement provided with the
	** Software or, alternatively, in accordance with the terms contained in
	** a written agreement between you and The Qt Company. For licensing terms
	** and conditions see https://www.qt.io/terms-conditions. For further
	** information use the contact form at https://www.qt.io/contact-us.
	**
	** GNU General Public License Usage
	** Alternatively, this file may be used under the terms of the GNU
	** General Public License version 3 as published by the Free Software
	** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
	** included in the packaging of this file. Please review the following
	** information to ensure the GNU General Public License requirements will
	** be met: https://www.gnu.org/licenses/gpl-3.0.html.
	**
	** $QT_END_LICENSE$
	**
	****************************************************************************/

	#include "tst_qmakelib.h"

	#include <ioutils.h>

	using namespace QMakeInternal;

	void tst_qmakelib::initTestCase()
	{
	m_indir = QFINDTESTDATA("testdata");
	m_outdir = m_indir + QLatin1String("_build");
	m_env.insert(QStringLiteral("E1"), QStringLiteral("env var"));
	#ifdef Q_OS_WIN
	m_env.insert(QStringLiteral("COMSPEC"), qgetenv("COMSPEC"));
	#endif
	m_prop.insert(ProKey("P1"), ProString("prop val"));
	m_prop.insert(ProKey("QT_HOST_DATA/get"), ProString(m_indir));
	m_prop.insert(ProKey("QT_HOST_DATA/src"), ProString(m_indir));

	QVERIFY(!m_indir.isEmpty());
	QVERIFY(QDir(m_outdir).removeRecursively());
	QVERIFY(QDir().mkpath(m_outdir));
	}

	void tst_qmakelib::cleanupTestCase()
	{
	QVERIFY(QDir(m_outdir).removeRecursively());
	}

	void tst_qmakelib::proString()
	{
	QString qs1(QStringLiteral("this is a string"));

	ProString s1(qs1);
	QCOMPARE(s1.toQString(), QStringLiteral("this is a string"));

	ProString s2(qs1, 5, 8);
	QCOMPARE(s2.toQString(), QStringLiteral("is a str"));

	QCOMPARE(s2.hash(), 0x80000000);
	qHash(s2);
	QCOMPARE(s2.hash(), 90404018U);

	QCOMPARE(s2.mid(0, 10).toQString(), QStringLiteral("is a str"));
	QCOMPARE(s2.mid(1, 5).toQString(), QStringLiteral("s a s"));
	QCOMPARE(s2.mid(10, 3).toQString(), QStringLiteral(""));

	QString qs2(QStringLiteral(" spacy string "));
	QCOMPARE(ProString(qs2, 3, 13).trimmed().toQString(), QStringLiteral("spacy string"));
	QCOMPARE(ProString(qs2, 1, 17).trimmed().toQString(), QStringLiteral("spacy string"));

	QVERIFY(s2.toQStringRef().string()->isSharedWith(qs1));
	s2.prepend(ProString("there "));
	QCOMPARE(s2.toQString(), QStringLiteral("there is a str"));
	QVERIFY(!s2.toQStringRef().string()->isSharedWith(qs1));

	ProString s3("this is a longish string with bells and whistles");
	s3 = s3.mid(18, 17);
	// Prepend to detached string with lots of spare space in it.
	s3.prepend(ProString("another "));
	QCOMPARE(s3.toQString(), QStringLiteral("another string with bells"));

	// Note: The string still has plenty of spare space.
	s3.append(QLatin1Char('.'));
	QCOMPARE(s3.toQString(), QStringLiteral("another string with bells."));
	s3.append(QLatin1String(" eh?"));
	QCOMPARE(s3.toQString(), QStringLiteral("another string with bells. eh?"));

	s3.append(ProString(" yeah!"));
	QCOMPARE(s3.toQString(), QStringLiteral("another string with bells. eh? yeah!"));

	bool pending = false; // Not in string, but joining => add space
	s3.append(ProString("..."), &pending);
	QCOMPARE(s3.toQString(), QStringLiteral("another string with bells. eh? yeah! ..."));
	QVERIFY(pending);

	ProStringList sl1;
	sl1 << ProString("") << ProString("foo") << ProString("barbaz");
	ProString s4a("hallo");
	s4a.append(sl1);
	QCOMPARE(s4a.toQString(), QStringLiteral("hallo foo barbaz"));
	ProString s4b("hallo");
	pending = false;
	s4b.append(sl1, &pending);
	QCOMPARE(s4b.toQString(), QStringLiteral("hallo foo barbaz"));
	ProString s4c;
	pending = false;
	s4c.append(sl1, &pending);
	QCOMPARE(s4c.toQString(), QStringLiteral(" foo barbaz"));
	// bizarreness
	ProString s4d("hallo");
	pending = false;
	s4d.append(sl1, &pending, true);
	QCOMPARE(s4d.toQString(), QStringLiteral("hallo foo barbaz"));
	ProString s4e;
	pending = false;
	s4e.append(sl1, &pending, true);
	QCOMPARE(s4e.toQString(), QStringLiteral("foo barbaz"));

	ProStringList sl2;
	sl2 << ProString("foo");
	ProString s5;
	s5.append(sl2);
	QCOMPARE(s5.toQString(), QStringLiteral("foo"));
	QVERIFY(s5.toQStringRef().string()->isSharedWith(*sl2.first().toQStringRef().string()));

	QCOMPARE(ProString("one") + ProString(" more"), QStringLiteral("one more"));
	}

	void tst_qmakelib::proStringList()
	{
	ProStringList sl1;
	sl1 << ProString("qt") << ProString(QLatin1String("is"))
	<< ProString(QStringLiteral("uncool")).mid(2);

	QCOMPARE(sl1.toQStringList(), QStringList() << "qt" << "is" << "cool");
	QCOMPARE(sl1.join(QStringLiteral("~~")), QStringLiteral("qt~~is~~cool"));

	ProStringList sl2;
	sl2 << ProString("mostly") << ProString("...") << ProString("is") << ProString("...");
	sl1.insertUnique(sl2);
	QCOMPARE(sl1.toQStringList(), QStringList() << "qt" << "is" << "cool" << "mostly" << "...");

	QVERIFY(sl1.contains("cool"));
	QVERIFY(!sl1.contains("COOL"));
	QVERIFY(sl1.contains("COOL", Qt::CaseInsensitive));
	}

	void tst_qmakelib::quoteArgUnix_data()
	{
	QTest::addColumn<QString>("in");
	QTest::addColumn<QString>("out");

	static const struct {
	const char * const in;
	const char * const out;
	} vals[] = {
	{ "", "''" },
	{ "hallo", "hallo" },
	{ "hallo du", "'hallo du'" },
	{ "ha'llo", "'ha'\\''llo'" },
	};

	for (unsigned i = 0; i < sizeof(vals)/sizeof(vals[0]); i++)
	QTest::newRow(vals[i].in) << QString::fromLatin1(vals[i].in)
	<< QString::fromLatin1(vals[i].out);
	}

	void tst_qmakelib::quoteArgUnix()
	{
	QFETCH(QString, in);
	QFETCH(QString, out);

	QCOMPARE(IoUtils::shellQuoteUnix(in), out);
	}

	void tst_qmakelib::quoteArgWin_data()
	{
	QTest::addColumn<QString>("in");
	QTest::addColumn<QString>("out");

	static const struct {
	const char * const in;
	const char * const out;
	} vals[] = {
	{ "", "\"\"" },
	{ "hallo", "hallo" },
	{ "hallo du", "\"hallo du\"" },
	{ "hallo\\", "hallo\\" },
	{ "hallo du\\", "\"hallo du\\\\\"" },
	{ "ha\"llo", "\"ha\\\"llo^\"" },
	{ "ha\\\"llo", "\"ha\\\\\\\"llo^\"" },
	};

	for (unsigned i = 0; i < sizeof(vals)/sizeof(vals[0]); i++)
	QTest::newRow(vals[i].in) << QString::fromLatin1(vals[i].in)
	<< QString::fromLatin1(vals[i].out);
	}

	void tst_qmakelib::quoteArgWin()
	{
	QFETCH(QString, in);
	QFETCH(QString, out);

	QCOMPARE(IoUtils::shellQuoteWin(in), out);
	}

	void tst_qmakelib::pathUtils()
	{
	QString afp = QCoreApplication::applicationFilePath();
	QVERIFY(IoUtils::exists(afp));
	QVERIFY(!IoUtils::exists(afp + "-tehfail"));
	QCOMPARE(IoUtils::fileType(afp), IoUtils::FileIsRegular);
	QString adp = QCoreApplication::applicationDirPath();
	QCOMPARE(IoUtils::fileType(adp), IoUtils::FileIsDir);

	QString fn0 = "file/path";
	QVERIFY(IoUtils::isRelativePath(fn0));

	QString fn1 = "/a/unix/file/path";
	QCOMPARE(IoUtils::pathName(fn1).toString(), QStringLiteral("/a/unix/file/"));
	QCOMPARE(IoUtils::fileName(fn1).toString(), QStringLiteral("path"));
	}

	void tst_qmakelib::ioUtilRelativity_data()
	{
	QTest::addColumn<QString>("path");
	QTest::addColumn<bool>("relative");

	static const struct {
	const char *name;
	const char *path;
	bool relative;
	} rows[] = {
	{ "resource", ":/resource",
	#ifdef QMAKE_BUILTIN_PRFS
	false
	#else
	true
	#endif
	},
	#ifdef Q_OS_WIN // all the complications:
	// (except UNC: unsupported)
	{ "drive-abs", "c:/path/to/file", false },
	{ "drive-abs-bs", "c:\\path\\to\\file", false },
	{ "drive-path", "c:path/to/file.txt", true },
	{ "drive-path-bs", "c:path\\to\\file.txt", true },
	{ "rooted", "/Users/qt/bin/true", true },
	{ "rooted-bs", "\\Users\\qt\\bin\\true", true },
	{ "drive-rel", "c:file.txt", true },
	{ "subdir-bs", "path\\to\\file", true },
	#else
	{ "rooted", "/usr/bin/false", false },
	#endif // Q_OS_WIN
	{ "subdir", "path/to/file", true },
	{ "simple", "file.name", true },
	{ "empty", "", true }
	};

	for (unsigned int i = sizeof(rows) / sizeof(rows[0]); i-- > 0; )
	QTest::newRow(rows[i].name) << QString::fromLatin1(rows[i].path)
	<< rows[i].relative;
	}

	void tst_qmakelib::ioUtilRelativity()
	{
	QFETCH(QString, path);
	QFETCH(bool, relative);

	QCOMPARE(IoUtils::isRelativePath(path), relative);
	}

	void tst_qmakelib::ioUtilResolve_data()
	{
	QTest::addColumn<QString>("base");
	QTest::addColumn<QString>("path");
	QTest::addColumn<QString>("expect");

	static const struct {
	const char *name;
	const char *base;
	const char *path;
	const char *expect;
	} data[] = {
	#ifdef Q_OS_WIN // all the complications:
	{ "drive-drive", "a:/ms/dir", "z:/root/file", "z:/root/file" },
	{ "drive-drive-bs", "a:\\ms\\dir", "z:\\root\\file", "z:/root/file" },
	{ "drive-root", "a:/ms/dir", "/root/file", "a:/root/file" },
	{ "drive-root-bs", "a:\\ms\\dir", "\\root\\file", "a:/root/file" },
	{ "drive-sub", "a:/ms/dir", "sub/file", "a:/ms/dir/sub/file" },
	{ "drive-sub-bs", "a:\\ms\\dir", "sub\\file", "a:/ms/dir/sub/file" },
	{ "drive-rel", "a:/ms/dir", "file.txt", "a:/ms/dir/file.txt" },
	{ "drive-rel-bs", "a:\\ms\\dir", "file.txt", "a:/ms/dir/file.txt" },
	#else
	{ "abs-abs", "/a/unix/dir", "/root/file", "/root/file" },
	{ "abs-sub", "/a/unix/dir", "sub/file", "/a/unix/dir/sub/file" },
	{ "abs-rel", "/a/unix/dir", "file.txt", "/a/unix/dir/file.txt" },
	#endif // Q_OS_WIN
	};

	for (unsigned i = sizeof(data) / sizeof(data[0]); i-- > 0; )
	QTest::newRow(data[i].name) << QString::fromLatin1(data[i].base)
	<< QString::fromLatin1(data[i].path)
	<< QString::fromLatin1(data[i].expect);
	}

	void tst_qmakelib::ioUtilResolve()
	{
	QFETCH(QString, base);
	QFETCH(QString, path);
	QFETCH(QString, expect);

	QCOMPARE(IoUtils::resolvePath(base, path), expect);
	}

	void QMakeTestHandler::print(const QString &fileName, int lineNo, int type, const QString &msg)
	{
	QString pfx = ((type & QMakeParserHandler::CategoryMask) == QMakeParserHandler::WarningMessage)
	? QString::fromLatin1("WARNING: ") : QString();
	if (lineNo)
	doPrint(QStringLiteral("%1%2:%3: %4").arg(pfx, fileName, QString::number(lineNo), msg));
	else
	doPrint(QStringLiteral("%1%2").arg(pfx, msg));
	}

	void QMakeTestHandler::doPrint(const QString &msg)
	{
	if (!expected.isEmpty() && expected.first() == msg) {
	expected.removeAt(0);
	} else {
	qWarning("%s", qPrintable(msg));
	printed = true;
	}
	}

	QTEST_MAIN(tst_qmakelib)