Revision control

// Copyright (C) 2026 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
+ #include "../client/testenum.h"
+
#include <QtOpenApiCommon/qoaihelpers.h>
#include <QtCore/qobject.h>
#include <QtCore/qscopeguard.h>
#include <QtTest/qtest.h>
#include <limits>
using namespace Qt::StringLiterals;
using namespace QtOpenApiCommon;
+ namespace QtOpenAPI {
+
class tst_Helpers : public QObject
{
Q_OBJECT
private Q_SLOTS:
void fromByteArray_QString_data();
void fromByteArray_QString();
void fromByteArray_QByteArray_data();
void fromByteArray_QByteArray();
void fromByteArray_QDateTime_data();
void fromByteArray_QDateTime();
void fromByteArray_QDate_data();
void fromByteArray_QDate();
void fromByteArray_bool_data();
void fromByteArray_bool();
void fromByteArray_qint32_data();
void fromByteArray_qint32();
void fromByteArray_qint64_data();
void fromByteArray_qint64();
void fromByteArray_float_data();
void fromByteArray_float();
void fromByteArray_double_data();
void fromByteArray_double();
+ void fromByteArray_enum_data();
+ void fromByteArray_enum();
};
void tst_Helpers::fromByteArray_QString_data()
{
QTest::addColumn<QByteArray>("input");
QTest::addColumn<QString>("expectedResult");
QTest::newRow("non-empty string") << "Non empty string"_ba << QString("Non empty string"_L1);
QTest::newRow("empty") << ""_ba << QString();
QTest::newRow("null") << QByteArray() << QString();
QTest::newRow("non-ASCII char") << "caf\xc3\xa9"_ba << u"café"_s;
QTest::newRow("unicode") << "\xe2\x98\x83\xe2\x9d\xa4\xe4\xb8\x96\xe7\x95\x8c"_ba << u"☃❤世界"_s;
QTest::newRow("very long string") << QByteArray(100000, 'x') << QString(100000, u'x');
QByteArray withNull = "ab";
withNull.append('\0');
withNull.append("cd");
QTest::newRow("embedded null") << withNull << QString::fromUtf8(withNull);
}
void tst_Helpers::fromByteArray_QString()
{
QFETCH(QByteArray, input);
QFETCH(QString, expectedResult);
QString result;
const bool ok = fromByteArray(input, result);
QVERIFY(ok);
QCOMPARE(result, expectedResult);
}
void tst_Helpers::fromByteArray_QByteArray_data()
{
QTest::addColumn<QByteArray>("input");
QTest::newRow("non-empty") << "hello"_ba;
QTest::newRow("empty") << ""_ba;
QTest::newRow("null") << QByteArray();
QTest::newRow("non-ASCII char") << "caf\xc3\xa9"_ba;
QByteArray withNull = "ab";
withNull.append('\0');
withNull.append("cd");
QTest::newRow("embedded null") << withNull;
}
void tst_Helpers::fromByteArray_QByteArray()
{
QFETCH(QByteArray, input);
QByteArray result;
const bool ok = fromByteArray(input, result);
QVERIFY(ok);
QCOMPARE(result, input);
}
void tst_Helpers::fromByteArray_QDateTime_data()
{
QTest::addColumn<QString>("format"); // empty = Qt::ISODate, "TextDate" = Qt::TextDate
QTest::addColumn<QByteArray>("input");
QTest::addColumn<bool>("expectedOk");
QTest::addColumn<QDateTime>("initialResult"); // initial value of result before the call
QTest::addColumn<QDateTime>("expectedResult");
const QDateTime expected(QDate(2026, 4, 27), QTime(12, 0, 0));
QTest::newRow("ISO 8601 format - dd/MM/yyyy rejected")
<< QString() << "27/04/2026 12:00:00"_ba << false << QDateTime() << QDateTime();
QTest::newRow("ISO 8601 format - valid")
<< QString() << "2026-04-27T12:00:00"_ba << true << QDateTime() << expected;
QTest::newRow("ISO 8601 format - invalid string") // value left intact
<< QString() << "2000-not-a-datetime"_ba << false << expected << expected;
QTest::newRow("custom format - valid")
<< u"dd/MM/yyyy HH:mm:ss"_s << "27/04/2026 12:00:00"_ba << true << QDateTime()
<< expected;
QTest::newRow("custom format - ISO 8601 input rejected")
<< u"dd/MM/yyyy HH:mm:ss"_s << "2026-04-27T12:00:00"_ba << false << expected
<< expected; // value left intact
QTest::newRow("TextDate format - valid")
<< u"TextDate"_s << "Mon Apr 27 12:00:00 2026"_ba << true << QDateTime() << expected;
}
void tst_Helpers::fromByteArray_QDateTime()
{
QFETCH(QString, format);
QFETCH(QByteArray, input);
QFETCH(bool, expectedOk);
QFETCH(QDateTime, initialResult);
QFETCH(QDateTime, expectedResult);
if (format.isEmpty())
QVERIFY(setDateTimeFormat(Qt::ISODate));
else if (format == "TextDate"_L1)
QVERIFY(setDateTimeFormat(Qt::TextDate));
else
QVERIFY(setDateTimeFormat(format));
const auto restoreFormat = qScopeGuard([] { setDateTimeFormat(Qt::ISODate); });
QDateTime result = initialResult;
const bool ok = fromByteArray(input, result);
QCOMPARE(ok, expectedOk);
QCOMPARE_EQ(result, expectedResult);
}
void tst_Helpers::fromByteArray_QDate_data()
{
QTest::addColumn<QByteArray>("input");
QTest::addColumn<bool>("expectedOk");
QTest::addColumn<QDate>("initialResult"); // initial value of result before the call
QTest::addColumn<QDate>("expectedResult");
const QDate expected(2026, 4, 27);
QTest::newRow("dd/MM/yyyy format rejected")
<< "27/04/2026"_ba << false << QDate() << QDate();
QTest::newRow("ISO 8601 format - valid")
<< "2026-04-27"_ba << true << QDate() << expected;
QTest::newRow("invalid string") // value left intact
<< "2000-not-a-date"_ba << false << expected << expected;
}
void tst_Helpers::fromByteArray_QDate()
{
QFETCH(QByteArray, input);
QFETCH(bool, expectedOk);
QFETCH(QDate, initialResult);
QFETCH(QDate, expectedResult);
QDate result = initialResult;
const bool ok = fromByteArray(input, result);
QCOMPARE(ok, expectedOk);
QCOMPARE_EQ(result, expectedResult);
}
void tst_Helpers::fromByteArray_bool_data()
{
QTest::addColumn<QByteArray>("input");
QTest::addColumn<bool>("expectedOk");
QTest::addColumn<bool>("initialResult"); // initial value of result before the call
QTest::addColumn<bool>("expectedResult");
QTest::newRow("true") << "true"_ba << true << false << true;
QTest::newRow("false") << "false"_ba << true << true << false;
QTest::newRow("truthy but not accepted") // value left intact
<< "1"_ba << false << false << false;
QTest::newRow("empty") // value left intact
<< ""_ba << false << true << true;
}
void tst_Helpers::fromByteArray_bool()
{
QFETCH(QByteArray, input);
QFETCH(bool, expectedOk);
QFETCH(bool, initialResult);
QFETCH(bool, expectedResult);
bool result = initialResult;
const bool ok = fromByteArray(input, result);
QCOMPARE(ok, expectedOk);
QCOMPARE(result, expectedResult);
}
void tst_Helpers::fromByteArray_qint32_data()
{
QTest::addColumn<QByteArray>("input");
QTest::addColumn<bool>("expectedOk");
QTest::addColumn<qint32>("initialResult"); // initial value of result before the call
QTest::addColumn<qint32>("expectedResult");
const qint64 overMax = static_cast<qint64>(std::numeric_limits<qint32>::max()) + 1;
const qint64 underMin = static_cast<qint64>(std::numeric_limits<qint32>::min()) - 1;
QTest::newRow("positive") << "42"_ba << true << qint32(0) << qint32(42);
QTest::newRow("negative") << "-1"_ba << true << qint32(0) << qint32(-1);
QTest::newRow("leading zeros") << "007"_ba << true << qint32(0) << qint32(7);
QTest::newRow("max") << QByteArray::number(std::numeric_limits<qint32>::max())
<< true << qint32(0) << std::numeric_limits<qint32>::max();
QTest::newRow("min") << QByteArray::number(std::numeric_limits<qint32>::min())
<< true << qint32(0) << std::numeric_limits<qint32>::min();
QTest::newRow("overflow") // value left intact
<< QByteArray::number(overMax) << false << qint32(99) << qint32(99);
QTest::newRow("underflow") // value left intact
<< QByteArray::number(underMin) << false << qint32(99) << qint32(99);
QTest::newRow("not a number") // value left intact
<< "not_a_number"_ba << false << qint32(99) << qint32(99);
QTest::newRow("empty") // value left intact
<< ""_ba << false << qint32(99) << qint32(99);
QTest::newRow("decimal point") // value left intact
<< "42.5"_ba << false << qint32(99) << qint32(99);
QTest::newRow("hex format") // value left intact
<< "0xFF"_ba << false << qint32(99) << qint32(99);
}
void tst_Helpers::fromByteArray_qint32()
{
QFETCH(QByteArray, input);
QFETCH(bool, expectedOk);
QFETCH(qint32, initialResult);
QFETCH(qint32, expectedResult);
qint32 result = initialResult;
const bool ok = fromByteArray(input, result);
QCOMPARE(ok, expectedOk);
QCOMPARE(result, expectedResult);
}
void tst_Helpers::fromByteArray_qint64_data()
{
QTest::addColumn<QByteArray>("input");
QTest::addColumn<bool>("expectedOk");
QTest::addColumn<qint64>("initialResult"); // initial value of result before the call
QTest::addColumn<qint64>("expectedResult");
const quint64 overMax = static_cast<quint64>(std::numeric_limits<qint64>::max()) + 1;
QTest::newRow("positive") << "42"_ba << true << qint64(0) << qint64(42);
QTest::newRow("leading zeros") << "007"_ba << true << qint64(0) << qint64(7);
QTest::newRow("max") << QByteArray::number(std::numeric_limits<qint64>::max())
<< true << qint64(0) << std::numeric_limits<qint64>::max();
QTest::newRow("min") << QByteArray::number(std::numeric_limits<qint64>::min())
<< true << qint64(0) << std::numeric_limits<qint64>::min();
QTest::newRow("overflow") // value left intact
<< QByteArray::number(overMax) << false << qint64(99) << qint64(99);
QTest::newRow("not a number") // value left intact
<< "not_a_number"_ba << false << qint64(99) << qint64(99);
QTest::newRow("empty") // value left intact
<< ""_ba << false << qint64(99) << qint64(99);
QTest::newRow("decimal point") // value left intact
<< "42.5"_ba << false << qint64(99) << qint64(99);
QTest::newRow("hex format") // value left intact
<< "0xFF"_ba << false << qint64(99) << qint64(99);
}
void tst_Helpers::fromByteArray_qint64()
{
QFETCH(QByteArray, input);
QFETCH(bool, expectedOk);
QFETCH(qint64, initialResult);
QFETCH(qint64, expectedResult);
qint64 result = initialResult;
const bool ok = fromByteArray(input, result);
QCOMPARE(ok, expectedOk);
QCOMPARE(result, expectedResult);
}
void tst_Helpers::fromByteArray_float_data()
{
QTest::addColumn<QByteArray>("input");
QTest::addColumn<bool>("expectedOk");
QTest::addColumn<float>("initialResult"); // initial value of result before the call
QTest::addColumn<float>("expectedResult");
QTest::newRow("positive") << "1.5"_ba << true << 0.0f << 1.5f;
QTest::newRow("negative") << "-2.5"_ba << true << 0.0f << -2.5f;
QTest::newRow("max") << QByteArray::number(std::numeric_limits<float>::max())
<< true << 0.0f << std::numeric_limits<float>::max();
QTest::newRow("min") << QByteArray::number(std::numeric_limits<float>::min())
<< true << 0.0f << std::numeric_limits<float>::min();
QTest::newRow("-inf") // value left intact
<< "-inf"_ba << false << 99.0f << 99.0f;
QTest::newRow("inf") // value left intact
<< "inf"_ba << false << 99.0f << 99.0f;
QTest::newRow("nan") // value left intact
<< "nan"_ba << false << 99.0f << 99.0f;
QTest::newRow("not a float") // value left intact
<< "not_a_float"_ba << false << 99.0f << 99.0f;
}
void tst_Helpers::fromByteArray_float()
{
QFETCH(QByteArray, input);
QFETCH(bool, expectedOk);
QFETCH(float, initialResult);
QFETCH(float, expectedResult);
float result = initialResult;
const bool ok = fromByteArray(input, result);
QCOMPARE(ok, expectedOk);
QCOMPARE(result, expectedResult);
}
void tst_Helpers::fromByteArray_double_data()
{
QTest::addColumn<QByteArray>("input");
QTest::addColumn<bool>("expectedOk");
QTest::addColumn<double>("initialResult"); // initial value of result before the call
QTest::addColumn<double>("expectedResult");
QTest::newRow("positive") << "1.5"_ba << true << 0.0 << 1.5;
QTest::newRow("negative") << "-2.5"_ba << true << 0.0 << -2.5;
QTest::newRow("max")
<< QByteArray::number(std::numeric_limits<double>::max(), 'g',
std::numeric_limits<double>::max_digits10)
<< true << 0.0 << std::numeric_limits<double>::max();
QTest::newRow("min")
<< QByteArray::number(std::numeric_limits<double>::min(), 'g',
std::numeric_limits<double>::max_digits10)
<< true << 0.0 << std::numeric_limits<double>::min();
QTest::newRow("-inf") // value left intact
<< "-inf"_ba << false << 99.0 << 99.0;
QTest::newRow("inf") // value left intact
<< "inf"_ba << false << 99.0 << 99.0;
QTest::newRow("nan") // value left intact
<< "nan"_ba << false << 99.0 << 99.0;
QTest::newRow("not a double") // value left intact
<< "not_a_double"_ba << false << 99.0 << 99.0;
}
void tst_Helpers::fromByteArray_double()
{
QFETCH(QByteArray, input);
QFETCH(bool, expectedOk);
QFETCH(double, initialResult);
QFETCH(double, expectedResult);
double result = initialResult;
const bool ok = fromByteArray(input, result);
QCOMPARE(ok, expectedOk);
QCOMPARE(result, expectedResult);
}
- QTEST_MAIN(tst_Helpers)
+ void tst_Helpers::fromByteArray_enum_data()
+ {
+ QTest::addColumn<QByteArray>("input");
+ QTest::addColumn<bool>("expectedOk");
+ QTest::addColumn<TestEnum::eTestEnum>("expectedResultValue");
+ QTest::addColumn<bool>("expectedResultValidity");
+
+ QTest::newRow("valid VALUE_A") << "VALUE_A"_ba << true << TestEnum::eTestEnum::VALUE_A
+ << true;
+ QTest::newRow("valid VALUE_B") << "VALUE_B"_ba << true << TestEnum::eTestEnum::VALUE_B
+ << true;
+ QTest::newRow("UNKNOWN") << "UNKNOWN"_ba << false
+ << TestEnum::eTestEnum::INVALID_VALUE_OPENAPI_GENERATED << false;
+ }
+
+ void tst_Helpers::fromByteArray_enum()
+ {
+ QFETCH(QByteArray, input);
+ QFETCH(bool, expectedOk);
+ QFETCH(TestEnum::eTestEnum, expectedResultValue);
+ QFETCH(bool, expectedResultValidity);
+
+ TestEnum result;
+
+ const bool ok = fromByteArray(input, result);
+ QCOMPARE(ok, expectedOk);
+ QCOMPARE(result.isValid(), expectedResultValidity);
+ QCOMPARE(result.getValue(), expectedResultValue);
+ }
+
+ } // QtOpenAPI
+
+ QTEST_MAIN(QtOpenAPI::tst_Helpers)
#include "tst_helpers.moc"