Revision control
Copy as Markdown
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
#if CHECK_SIMTEXTH
#include "../shared/simtexth.h"
#endif
#include <QtCore/QByteArray>
#include <QtCore/QDebug>
#include <QtCore/QDir>
#include <QtCore/QFile>
#include <QtCore/QElapsedTimer>
#include <QtCore/private/qconfig_p.h>
#include <QtCore/QSet>
#include <QtCore/QSysInfo>
#include <QtTest/QtTest>
#include <QtTools/private/qttools-config_p.h>
#include <algorithm>
#include <limits>
using namespace Qt::Literals::StringLiterals;
static constexpr int TIMEOUT = 120000;
class tst_lupdate : public QObject
{
Q_OBJECT
public:
tst_lupdate();
private slots:
void cleanupTestCase();
void good_data();
void good();
#if CHECK_SIMTEXTH
void simtexth();
void simtexth_data();
#endif
private:
QString m_cmdLupdate;
QString m_cmdLupdatePro;
QString m_basePath;
QElapsedTimer m_timer;
qint64 m_maxElapsed = -1;
static void doCompare(QList<QStringView> actual, const QString &expectedFn, bool err);
void doCompare(const QString &actualFn, const QString &expectedFn, bool err);
};
tst_lupdate::tst_lupdate()
{
m_timer.start();
QString binPath = QLibraryInfo::path(QLibraryInfo::BinariesPath);
m_cmdLupdate = binPath + "/lupdate"_L1;
m_cmdLupdatePro = binPath + "/lupdate-pro"_L1;
m_basePath = QFINDTESTDATA("testdata/");
}
void tst_lupdate::cleanupTestCase()
{
if (m_maxElapsed > 0)
qInfo().noquote().nospace() << "max elapsed: " << m_maxElapsed << "ms";
}
static bool prepareMatch(QStringView expect, QString *tmpl, qsizetype *require, qsizetype *accept)
{
if (expect.startsWith(QLatin1Char('\\'))) {
*tmpl = expect.sliced(1).toString();
*require = *accept = 1;
} else if (expect.startsWith(u'?')) {
*tmpl = expect.sliced(1).toString();
*require = 0;
*accept = 1;
} else if (expect.startsWith(u'*')) {
*tmpl = expect.sliced(1).toString();
*require = 0;
*accept = std::numeric_limits<qsizetype>::max();
} else if (expect.startsWith(u'+')) {
*tmpl = expect.sliced(1).toString();
*require = 1;
*accept = std::numeric_limits<qsizetype>::max();
} else if (expect.startsWith(u'{')) {
const auto brc = expect.indexOf(u'}', 1);
if (brc < 0)
return false;
*tmpl = expect.sliced(brc + 1).toString();
auto sub = expect.sliced(1, brc - 1);
const auto com = sub.indexOf(u',');
bool ok{};
if (com < 0) {
*require = *accept = sub.toInt(&ok);
return ok;
}
*require = sub.left(com).toInt();
*accept = sub.sliced(com + 1).toInt(&ok);
if (!ok)
*accept = std::numeric_limits<qsizetype>::max();
return *accept >= *require;
} else {
*tmpl = expect.toString();
*require = *accept = 1;
}
return true;
}
static bool isStashMessage(QStringView v)
{
return v.startsWith("Info: creating stash file "_L1);
}
void tst_lupdate::doCompare(QList<QStringView> actual, const QString &expectedFn, bool err)
{
QFile file(expectedFn);
QVERIFY2(file.open(QIODevice::ReadOnly | QIODevice::Text), qPrintable(expectedFn));
const QString expectedS = QString::fromUtf8(file.readAll());
auto expected = QStringView{expectedS}.split(u'\n');
actual.erase(std::remove_if(actual.begin(), actual.end(), isStashMessage), actual.end());
qsizetype ei = 0, ai = 0, em = expected.size(), am = actual.size();
qsizetype oei = 0, oai = 0, oem = em, oam = am;
qsizetype require = 0, accept = 0;
QString tmpl;
forever {
if (!accept) {
oei = ei, oai = ai;
if (ei == em) {
if (ai == am)
return;
break;
}
if (!prepareMatch(expected.at(ei++), &tmpl, &require, &accept))
QFAIL(qPrintable(QString("Malformed expected %1 at %3:%2"_L1)
.arg(err ? "output"_L1 : "result"_L1).arg(ei).arg(expectedFn)));
}
if (ai == am) {
if (require <= 0) {
accept = 0;
continue;
}
break;
}
if (err
? !QRegularExpression(QRegularExpression::anchoredPattern(tmpl)).matchView(actual.at(ai)).hasMatch()
: (actual.at(ai) != tmpl)) {
if (require <= 0) {
accept = 0;
continue;
}
ei--;
require = accept = 0;
forever {
if (!accept) {
oem = em, oam = am;
if (ei == em)
break;
if (!prepareMatch(expected.at(--em), &tmpl, &require, &accept))
QFAIL(qPrintable(QString("Malformed expected %1 at %3:%2"_L1)
.arg(err ? "output"_L1 : "result"_L1)
.arg(em + 1).arg(expectedFn)));
}
if (ai == am || (err
? !QRegularExpression(QRegularExpression::anchoredPattern(tmpl)).matchView(actual.at(am - 1)).hasMatch()
: (actual.at(am - 1) != tmpl))) {
if (require <= 0) {
accept = 0;
continue;
}
break;
}
accept--;
require--;
am--;
}
break;
}
accept--;
require--;
ai++;
}
QString diff;
for (qsizetype j = qMax(qsizetype(0), oai - 3); j < oai; j++) {
diff += actual.at(j);
diff += u'\n';
}
diff += "<<<<<<< got\n"_L1;
for (qsizetype j = oai; j < oam; j++) {
diff += actual.at(j);
diff += u'\n';
if (j >= oai + 5) {
diff += "...\n"_L1;
break;
}
}
diff += "=========\n"_L1;
for (qsizetype j = oei; j < oem; j++) {
diff += expected.at(j);
diff += u'\n';
if (j >= oei + 5) {
diff += "...\n"_L1;
break;
}
}
diff += ">>>>>>> expected\n"_L1;
for (qsizetype j = oam; j < qMin(oam + 3, actual.size()); j++) {
diff += actual.at(j);
diff += u'\n';
}
QFAIL(qPrintable((err ? "Output for "_L1 : "Result for "_L1)
+ expectedFn + " does not meet expectations:\n"_L1 + diff));
}
void tst_lupdate::doCompare(const QString &actualFn, const QString &expectedFn, bool err)
{
QFile afile(actualFn);
QVERIFY2(afile.open(QIODevice::ReadOnly | QIODevice::Text), qPrintable(actualFn));
const QString actual = QString::fromUtf8(afile.readAll());
doCompare(QStringView{actual}.split(u'\n'), expectedFn, err);
}
void tst_lupdate::good_data()
{
QTest::addColumn<QString>("directory");
QDir parsingDir(m_basePath + "good"_L1);
QStringList dirs = parsingDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot, QDir::Name);
#ifndef Q_OS_WIN
dirs.removeAll("backslashes"_L1);
#endif
#ifndef Q_OS_MACOS
dirs.removeAll("parseobjc"_L1);
#endif
for (const QString &dir : dirs) {
QTest::newRow(dir.toLocal8Bit().constData()) << dir;
}
}
static QByteArray msgStartFailed(const QProcess &process)
{
const QString result = u'"' + process.program() + u' ' + process.arguments().join(u' ')
+ "\": "_L1 + process.errorString();
return result.toLocal8Bit();
}
static QByteArray msgTimeout(const QProcess &process)
{
const QString result = u'"' + process.program() + u' ' + process.arguments().join(u' ')
+ "\" timed out: "_L1 + process.errorString();
return result.toLocal8Bit();
}
static QByteArray msgCrashed(const QProcess &process, const QByteArray &output)
{
const QString result = u'"' + process.program() + u' ' + process.arguments().join(u' ')
+ "\" crashed\n"_L1;
return result.toLocal8Bit() + output;
}
static QByteArray msgExitCode(const QProcess &process, const QByteArray &output)
{
const QString result = u'"' + process.program() + u' ' + process.arguments().join(u' ')
+ "\" exited with code "_L1 + QString::number(process.exitCode())
+ u'\n';
return result.toLocal8Bit() + output;
}
void tst_lupdate::good()
{
QFETCH(QString, directory);
QString dir = m_basePath + "good/"_L1 + directory;
QString workDir = dir;
QStringList generatedtsfiles("project.ts"_L1);
QStringList lupdateArguments;
QFile file(dir + "/lupdatecmd"_L1);
if (file.exists()) {
QVERIFY2(file.open(QIODevice::ReadOnly | QIODevice::Text), qPrintable(file.fileName()));
while (!file.atEnd()) {
QByteArray cmdstring = file.readLine().simplified();
if (cmdstring.startsWith(u'#'))
continue;
if (cmdstring.startsWith("lupdate"_L1)) {
for (auto argument : cmdstring.sliced(8).simplified().split(' '))
lupdateArguments += argument;
break;
}
if (cmdstring.startsWith("TRANSLATION:"_L1)) {
cmdstring.remove(0, 12);
generatedtsfiles.clear();
const auto parts = cmdstring.split(u' ');
for (const QByteArray &s : parts)
if (!s.isEmpty())
generatedtsfiles << QLatin1StringView(s);
} else if (cmdstring.startsWith("cd "_L1)) {
cmdstring.remove(0, 3);
workDir = QDir::cleanPath(dir + u'/' + QLatin1StringView(cmdstring));
}
}
file.close();
}
for (const QString &ts : std::as_const(generatedtsfiles)) {
QString genTs = workDir + u'/' + ts;
QFile::remove(genTs);
QString beforetsfile = dir + u'/' + ts + ".before"_L1;
if (QFile::exists(beforetsfile))
QVERIFY2(QFile::copy(beforetsfile, genTs), qPrintable(beforetsfile));
}
file.setFileName(workDir + "/.qmake.cache"_L1);
QVERIFY(file.open(QIODevice::WriteOnly));
file.close();
if (lupdateArguments.isEmpty()) {
// Automatically pass "project.pro" or "-project project.json".
if (QFile::exists(dir + u"/project.json"_s)) {
lupdateArguments << u"-project"_s << u"project.json"_s;
} else {
lupdateArguments.append("project.pro"_L1);
}
}
lupdateArguments.prepend("-silent"_L1);
QString command;
if (lupdateArguments.contains("project.pro"_L1)
|| lupdateArguments.contains("subdir1/subdir1.pro"_L1))
command = m_cmdLupdatePro;
else
command = m_cmdLupdate;
QProcess proc;
proc.setWorkingDirectory(workDir);
proc.setProcessChannelMode(QProcess::MergedChannels);
const auto startTime = m_timer.elapsed();
proc.start(command, lupdateArguments, QIODevice::ReadWrite | QIODevice::Text);
QVERIFY2(proc.waitForStarted(), msgStartFailed(proc).constData());
if (!proc.waitForFinished(TIMEOUT)) {
const auto message = msgTimeout(proc);
proc.kill();
proc.waitForFinished(50);
QFAIL(message.constData());
}
const auto elapsed = m_timer.elapsed() - startTime;
if (elapsed > m_maxElapsed)
m_maxElapsed = elapsed;
const QByteArray output = proc.readAll();
QVERIFY2(proc.exitStatus() == QProcess::NormalExit, msgCrashed(proc, output).constData());
QVERIFY2(proc.exitCode() == 0, msgExitCode(proc, output).constData());
qInfo().noquote().nospace() << elapsed << "ms";
// If the file expectedoutput.txt exists, compare the
// console output with the content of that file
QFile outfile(dir + "/expectedoutput.txt"_L1);
if (outfile.exists()) {
const QString errslist = QString::fromLocal8Bit(output);
doCompare(QStringView{errslist}.split(u'\n'), outfile.fileName(), true);
if (QTest::currentTestFailed())
return;
}
for (const QString &ts : std::as_const(generatedtsfiles)) {
doCompare(workDir + u'/' + ts,
dir + u'/' + ts + ".result"_L1, false);
}
}
#if CHECK_SIMTEXTH
void tst_lupdate::simtexth()
{
QFETCH(QString, one);
QFETCH(QString, two);
QFETCH(int, expected);
int measured = getSimilarityScore(one, two.toLatin1());
QCOMPARE(measured, expected);
}
void tst_lupdate::simtexth_data()
{
using namespace QTest;
addColumn<QString>("one");
addColumn<QString>("two");
addColumn<int>("expected");
newRow("00") << "" << "" << 1024;
newRow("01") << "a" << "a" << 1024;
newRow("02") << "ab" << "ab" << 1024;
newRow("03") << "abc" << "abc" << 1024;
newRow("04") << "abcd" << "abcd" << 1024;
}
#endif
QTEST_MAIN(tst_lupdate)
#include "tst_lupdate.moc"