tst_oneof.cpp - mozsearch

// Copyright (C) 2026 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

#include "qoaicommonglobal.h"

#include "../basicSchemaAlternatives/client/bankapi.h"

#include "../basicSchemaAlternatives/client/dataapi.h"

#include "../basicSchemaAlternatives/client/defaultapi.h"

#include "../basicSchemaAlternatives/client/dummytestvalue.h"

#include "../basicSchemaAlternatives/client/farmapi.h"

#include "../basicSchemaAlternatives/client/root.h"

#include "../basicSchemaAlternatives/client/rootmap.h"

#include "../basicSchemaAlternatives/client/rootmapmodels.h"

#include "../basicSchemaAlternatives/client/storeapi.h"

#include <QtCore/qbuffer.h>

#include <QtCore/qobject.h>

#include <QtNetwork/qnetworkrequestfactory.h>

#include <QtNetwork/qrestaccessmanager.h>

#include <QtTest/qtest.h>

using namespace Qt::StringLiterals;

using namespace QtOpenApiCommon;

static QString mapAsString(const QMap<QString, QJsonValue> &map)

    QJsonObject obj;

    for (const auto &[key, val] : map.asKeyValueRange())

        obj.insert(key, val);

    return QString::fromUtf8(QJsonDocument(obj).toJson(QJsonDocument::Compact));

class LoggingNetworkAccessManager : public QNetworkAccessManager

public:

    LoggingNetworkAccessManager(QObject *parent = nullptr)

        : QNetworkAccessManager(parent)

{}

    ~LoggingNetworkAccessManager() override

{}

protected:

    QNetworkReply *createRequest(QNetworkAccessManager::Operation op,

                                 const QNetworkRequest &originalReq,

                                 QIODevice *outgoingData = nullptr) override;

public:

    QByteArray m_content;

};

QNetworkReply *LoggingNetworkAccessManager::createRequest(QNetworkAccessManager::Operation op,

                                                          const QNetworkRequest &originalReq,

                                                          QIODevice *outgoingData)

    // The QNAM::put/post/sendCustomRequest operations that take QByteArray

    // as a data parameter use QBuffer to wrap the byte array.

    // It is later passed as a QIODevice* to this method.

    // We cast the QIODevice to QBuffer, and store its content to intercept

    // the transferred data.

    QBuffer *buffer = qobject_cast<QBuffer*>(outgoingData);

    m_content = buffer ? buffer->data() : QByteArray();

    return QNetworkAccessManager::createRequest(op, originalReq, outgoingData);

class OneOfTest : public QObject {

    Q_OBJECT

    enum class BankApiPatchMode {

        UsePatchPaymentRequest,

        UseString,

        UseBool,

        UseDouble

};

    enum class BankApiPostMode {

        UsePostPaymentRequest,

        UseCreditCard,

        UsePaypal

};

    enum class StoreApiMode {

        UseCat,

        UseDog,

        UsePet

};

    enum class FarmApiMode {

        UseBunny,

        UseDog,

        UseDuck,

        UsePostPet

};

private:

    void generateAlternativeSchemasTestData();

private Q_SLOTS:

    void testAccountJsonConversionMethods_data();

    void testAccountJsonConversionMethods();

    void testAlternativeSchemasFunctions_data();

    void testAlternativeSchemasFunctions();

    void testAlternativeSchemasOptional_data();

    void testAlternativeSchemasOptional();

    void testAlternativeSchemasRequired_data();

    void testAlternativeSchemasRequired();

    void testClientValueJsonConversionMethods_data();

    void testClientValueJsonConversionMethods();

    void testCustomerJsonConversionMethods_data();

    void testCustomerJsonConversionMethods();

    void testInlineSchemasJsonConversionMethods_data();

    void testInlineSchemasJsonConversionMethods();

    void testInlineSchemasPatch_data();

    void testInlineSchemasPatch();

    void testInlineSchemasPost_data();

    void testInlineSchemasPost();

    void testOneOfPrimitiveJsonConversionMethods_data();

    void testOneOfPrimitiveJsonConversionMethods();

    void testPolymorphedRequestBody_data();

    void testPolymorphedRequestBody();

    void testPostAccountRequestJsonConversionMethods_data();

    void testPostAccountRequestJsonConversionMethods();

    void testPostFarmPetRequestJsonConversionMethods_data();

    void testPostFarmPetRequestJsonConversionMethods();

    void testDummyTestValue();

    void testRootJsonConversionMethods_data();

    void testRootJsonConversionMethods();

    void testRootMapJsonConversionMethods_data();

    void testRootMapJsonConversionMethods();

    void testRootMapModelsJsonConversionMethods_data();

    void testRootMapModelsJsonConversionMethods();

};

void OneOfTest::testAccountJsonConversionMethods_data()

    QTest::addColumn<SchemasModelsOneOf::Account>("account");

    QTest::addColumn<QString>("expectedJson");

    QTest::addColumn<QJsonValue>("expectedJsonValue");

    QTest::addColumn<QString>("oneOf0ExpectedJson");

    QTest::addColumn<QString>("oneOf1ExpectedJson");

    QTest::addColumn<bool>("isOneOfAccountOneOfValid");

    QTest::addColumn<bool>("isOneOfAccountOneOfSet");

    QTest::addColumn<bool>("isOneOfAccountOneOf1Valid");

    QTest::addColumn<bool>("isOneOfAccountOneOf1Set");

    QTest::addColumn<bool>("isValid");

    QTest::addColumn<bool>("isSet");

    // Account has two oneOf alternatives:

    // oneOf0: Account_oneOf (name: string optional, contractAvailable: bool optional) =>

    // no required

    // oneOf1: Account_oneOf_1 (firstname: string optional, lastname: string optional,

    // additionalProperties) - no required

    // Both have no required fields => both are always "valid"

    // This creates ambiguity with empty JSON since both alternatives are valid!

    SchemasModelsOneOf::Account account;

    QTest::newRow("Empty Account object")

        // account                        // expectedJson

        << account                        << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOfAccountOneOfValid       // isOneOfAccountOneOfSet

        << false                          << false

        // isOneOfAccountOneOf1Valid      // isOneOfAccountOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Set a valid Account_oneOf via setter

    SchemasModelsOneOf::Account_oneOf acctOneOf0;

    acctOneOf0.setName("Test Account"_L1);

    acctOneOf0.setContractAvailable(true);

    account.setOneOfAccount_oneOf(acctOneOf0);

    QTest::newRow("Set a valid Account_oneOf object via setter")

        // account                        // expectedJson

        << account                        << acctOneOf0.asJson()

        // expectedJsonValue

        << acctOneOf0.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << acctOneOf0.asJson()            << QString("{}"_L1)

        // isOneOfAccountOneOfValid       // isOneOfAccountOneOfSet

        << true                           << true

        // isOneOfAccountOneOf1Valid      // isOneOfAccountOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set a valid Account_oneOf_1 via setter

    SchemasModelsOneOf::Account_oneOf_1 acctOneOf1;

    acctOneOf1.setFirstname("John"_L1);

    acctOneOf1.setLastname("Doe"_L1);

    account.setOneOfAccount_oneOf_1(acctOneOf1);

    QTest::newRow("Set a valid Account_oneOf_1 object via setter")

        // account                        // expectedJson

        << account                        << acctOneOf1.asJson()

        // expectedJsonValue

        << acctOneOf1.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << acctOneOf1.asJson()

        // isOneOfAccountOneOfValid       // isOneOfAccountOneOfSet

        << false                          << false

        // isOneOfAccountOneOf1Valid      // isOneOfAccountOneOf1Set

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    const SchemasModelsOneOf::Account_oneOf emptyAcctOneOf0;

    account.setOneOfAccount_oneOf(emptyAcctOneOf0);

    QTest::newRow("Set an empty Account_oneOf object via setter")

        // account                        // expectedJson

        << account                        << emptyAcctOneOf0.asJson()

        // expectedJsonValue

        << emptyAcctOneOf0.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOfAccountOneOfValid       // isOneOfAccountOneOfSet

        << true                           << true

        // isOneOfAccountOneOf1Valid      // isOneOfAccountOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set an empty Account_oneOf_1 object. No required fields, so it's VALID.

    const SchemasModelsOneOf::Account_oneOf_1 emptyAcctOneOf1;

    account.setOneOfAccount_oneOf_1(emptyAcctOneOf1);

    QTest::newRow("Set an empty Account_oneOf_1 object via setter")

        // account                        // expectedJson

        << account                        << emptyAcctOneOf1.asJson()

        // expectedJsonValue

        << emptyAcctOneOf1.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOfAccountOneOfValid       // isOneOfAccountOneOfSet

        << false                          << false

        // isOneOfAccountOneOf1Valid      // isOneOfAccountOneOf1Set

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue with EMPTY data => ambiguity, both are valid

    // Resolution: first valid alternative wins (oneOf0)

    account.fromJsonValue(emptyAcctOneOf0.asJsonValue());

    QTest::newRow("Set an empty Account_oneOf via ::fromJsonValue()")

        // account                        // expectedJson

        << account                        << emptyAcctOneOf0.asJson()

        // expectedJsonValue

        << emptyAcctOneOf0.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // !!! NOTE: ambiguity - both coule be valid, but oneOf0 wins

        // isOneOfAccountOneOfValid       // isOneOfAccountOneOfSet

        << true                           << true

        // isOneOfAccountOneOf1Valid      // isOneOfAccountOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson with EMPTY data => same ambiguity

    account.fromJson("{}"_L1);

    QTest::newRow("Set an empty JSON {} via ::fromJson()")

        // account                        // expectedJson

        << account                        << QString("{}"_L1)

        // expectedJsonValue

        << account.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // !!! NOTE: ambiguity - both could be valid, oneOf0 wins

        // isOneOfAccountOneOfValid       // isOneOfAccountOneOfSet

        << true                           << true

        // isOneOfAccountOneOf1Valid      // isOneOfAccountOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson with Account_oneOf specific field (name)

    const QString nameOnly("{\"name\":\"Acme Corp\"}"_L1);

    account.fromJson(nameOnly);

    QTest::newRow("Set Account_oneOf with name via ::fromJson()")

        // account                        // expectedJson

        << account                        << nameOnly

        // expectedJsonValue

        << account.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << nameOnly                       << QString("{}"_L1)

        // isOneOfAccountOneOfValid       // isOneOfAccountOneOfSet

        << true                           << true

        // isOneOfAccountOneOf1Valid      // isOneOfAccountOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson with Account_oneOf specific field (contractAvailable)

    const QString contractOnly("{\"contractAvailable\":false}"_L1);

    account.fromJson(contractOnly);

    QTest::newRow("Set Account_oneOf with contractAvailable via ::fromJson()")

        // account                        // expectedJson

        << account                        << contractOnly

        // expectedJsonValue

        << account.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << contractOnly                   << QString("{}"_L1)

        // isOneOfAccountOneOfValid       // isOneOfAccountOneOfSet

        << true                           << true

        // isOneOfAccountOneOf1Valid      // isOneOfAccountOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson with Account_oneOf_1 specific field (firstname)

    const QString firstnameOnly("{\"firstname\":\"Alice\"}"_L1);

    account.fromJson(firstnameOnly);

    QTest::newRow("Set Account_oneOf_1 with firstname via ::fromJson()")

        // account                        // expectedJson

        << account                        << firstnameOnly

        // expectedJsonValue

        << account.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << firstnameOnly

        // isOneOfAccountOneOfValid       // isOneOfAccountOneOfSet

        << false                          << false

        // isOneOfAccountOneOf1Valid      // isOneOfAccountOneOf1Set

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // fromJson with Account_oneOf_1 both fields

    const QString fullName("{\"firstname\":\"Bob\",\"lastname\":\"Smith\"}"_L1);

    account.fromJson(fullName);

    QTest::newRow("Set Account_oneOf_1 with both names via ::fromJson()")

        // account                        // expectedJson

        << account                        << fullName

        // expectedJsonValue

        << account.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << fullName

        // isOneOfAccountOneOfValid       // isOneOfAccountOneOfSet

        << false                          << false

        // isOneOfAccountOneOf1Valid      // isOneOfAccountOneOf1Set

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // fromJson with Account_oneOf both fields

    const QString fullAcct("{\"contractAvailable\":true,\"name\":\"Premium\"}"_L1);

    account.fromJson(fullAcct);

    QTest::newRow("Set Account_oneOf with both fields via ::fromJson()")

        // account                        // expectedJson

        << account                        << fullAcct

        // expectedJsonValue

        << account.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << fullAcct                       << QString("{}"_L1)

        // isOneOfAccountOneOfValid       // isOneOfAccountOneOfSet

        << true                           << true

        // isOneOfAccountOneOf1Valid      // isOneOfAccountOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue with valid Account_oneOf object

    account.fromJsonValue(acctOneOf0.asJsonValue());

    QTest::newRow("Set a valid Account_oneOf via ::fromJsonValue()")

        // account                        // expectedJson

        << account                        << acctOneOf0.asJson()

        // expectedJsonValue

        << account.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << acctOneOf0.asJson()            << QString("{}"_L1)

        // isOneOfAccountOneOfValid       // isOneOfAccountOneOfSet

        << true                           << true

        // isOneOfAccountOneOf1Valid      // isOneOfAccountOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue with valid Account_oneOf_1 object

    account.fromJsonValue(acctOneOf1.asJsonValue());

    QTest::newRow("Set a valid Account_oneOf_1 via ::fromJsonValue()")

        // account                        // expectedJson

        << account                        << acctOneOf1.asJson()

        // expectedJsonValue

        << account.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << acctOneOf1.asJson()

        // isOneOfAccountOneOfValid       // isOneOfAccountOneOfSet

        << false                          << false

        // isOneOfAccountOneOf1Valid      // isOneOfAccountOneOf1Set

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // invalid json! => the model is RESET to INITIAL state

    account.fromJson("{invalid json}"_L1);

    QTest::newRow("Set an invalid json via ::fromJson()")

        // account                        // expectedJson

        << account                        << QString("{}"_L1)

        // expectedJsonValue

        << account.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOfAccountOneOfValid       // isOneOfAccountOneOfSet

        << false                          << false

        // isOneOfAccountOneOf1Valid      // isOneOfAccountOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Test with non-object JSON (array) => reset

    account.fromJson("[]"_L1);

    QTest::newRow("Account: set an unexpected array via ::fromJson()")

        // account                        // expectedJson

        << account                        << QString("{}"_L1)

        // expectedJsonValue

        << account.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOfAccountOneOfValid       // isOneOfAccountOneOfSet

        << false                          << false

        // isOneOfAccountOneOf1Valid      // isOneOfAccountOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Test with non-object JSON (string) => reset

    account.fromJson("\"string\""_L1);

    QTest::newRow("Set an unexpected string via ::fromJson()")

        // account                        // expectedJson

        << account                        << QString("{}"_L1)

        // expectedJsonValue

        << account.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOfAccountOneOfValid       // isOneOfAccountOneOfSet

        << false                          << false

        // isOneOfAccountOneOf1Valid      // isOneOfAccountOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Invalid field types in Account_oneOf: name should be string

    account.fromJson("{\"name\":123,\"contractAvailable\":true}"_L1);

    QTest::newRow("Invalid field 'name=123' in Account_oneOf via ::fromJson()")

        // account                        // expectedJson

        << account                        << QString("{\"contractAvailable\":true}"_L1)

        // expectedJsonValue

        << account.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{\"contractAvailable\":true}"_L1) << QString("{}"_L1)

        // isOneOfAccountOneOfValid       // isOneOfAccountOneOfSet

        << true                           << true

        // isOneOfAccountOneOf1Valid      // isOneOfAccountOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Invalid field types in Account_oneOf: contractAvailable should be bool

    account.fromJson("{\"name\":\"ok\",\"contractAvailable\":\"yes\"}"_L1);

    QTest::newRow("Invalid field 'contractAvailable=yes' in Account_oneOf via ::fromJson()")

        // account                        // expectedJson

        << account                        << QString("{\"name\":\"ok\"}"_L1)

        // expectedJsonValue

        << account.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{\"name\":\"ok\"}"_L1) << QString("{}"_L1)

        // isOneOfAccountOneOfValid       // isOneOfAccountOneOfSet

        << true                           << true

        // isOneOfAccountOneOf1Valid      // isOneOfAccountOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Account_oneOf with only name set via setter

    SchemasModelsOneOf::Account_oneOf nameOnlyAcct;

    nameOnlyAcct.setName("PartialName"_L1);

    account.setOneOfAccount_oneOf(nameOnlyAcct);

    QTest::newRow("Set Account_oneOf with only name via setter")

        // account                        // expectedJson

        << account                        << nameOnlyAcct.asJson()

        // expectedJsonValue

        << nameOnlyAcct.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << nameOnlyAcct.asJson()          << QString("{}"_L1)

        // isOneOfAccountOneOfValid       // isOneOfAccountOneOfSet

        << true                           << true

        // isOneOfAccountOneOf1Valid      // isOneOfAccountOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Account_oneOf_1 with only lastname set via setter

    SchemasModelsOneOf::Account_oneOf_1 lastnameOnlyAcct;

    lastnameOnlyAcct.setLastname("OnlyLast"_L1);

    account.setOneOfAccount_oneOf_1(lastnameOnlyAcct);

    QTest::newRow("Set Account_oneOf_1 with only lastname via setter")

        // account                        // expectedJson

        << account                        << lastnameOnlyAcct.asJson()

        // expectedJsonValue

        << lastnameOnlyAcct.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << lastnameOnlyAcct.asJson()

        // isOneOfAccountOneOfValid       // isOneOfAccountOneOfSet

        << false                          << false

        // isOneOfAccountOneOf1Valid      // isOneOfAccountOneOf1Set

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

void OneOfTest::testAccountJsonConversionMethods()

    QFETCH(SchemasModelsOneOf::Account, account);

    QFETCH(QString, expectedJson);

    QFETCH(QJsonValue, expectedJsonValue);

    QFETCH(QString, oneOf0ExpectedJson);

    QFETCH(QString, oneOf1ExpectedJson);

    QFETCH(bool, isOneOfAccountOneOfValid);

    QFETCH(bool, isOneOfAccountOneOfSet);

    QFETCH(bool, isOneOfAccountOneOf1Valid);

    QFETCH(bool, isOneOfAccountOneOf1Set);

    QFETCH(bool, isValid);

    QFETCH(bool, isSet);

    QCOMPARE(account.asJson(), expectedJson);

    QCOMPARE(account.asJsonValue(), expectedJsonValue);

    QCOMPARE(account.getOneOfAccount_oneOf().asJson(), oneOf0ExpectedJson);

    QCOMPARE(account.isOneOfAccountOneOfValid(), isOneOfAccountOneOfValid);

    QCOMPARE(account.isOneOfAccountOneOfSet(), isOneOfAccountOneOfSet);

    QCOMPARE(account.getOneOfAccount_oneOf_1().asJson(), oneOf1ExpectedJson);

    QCOMPARE(account.isOneOfAccountOneOf1Valid(), isOneOfAccountOneOf1Valid);

    QCOMPARE(account.isOneOfAccountOneOf1Set(), isOneOfAccountOneOf1Set);

    QCOMPARE(account.isValid(), isValid);

    QCOMPARE(account.isSet(), isSet);

void OneOfTest::testAlternativeSchemasFunctions_data()

    QTest::addColumn<SchemasModelsOneOf::Pet>("pet");

    QTest::addColumn<QString>("expectedJson");

    QTest::addColumn<QJsonValue>("expectedJsonValue");

    QTest::addColumn<QString>("oneOfCatExpectedJson");

    QTest::addColumn<QString>("oneOfDogExpectedJson");

    QTest::addColumn<SchemasModelsOneOf::Cat>("getOneOfCat");

    QTest::addColumn<SchemasModelsOneOf::Dog>("getOneOfDog");

    QTest::addColumn<bool>("isOneOfCatValid");

    QTest::addColumn<bool>("isOneOfCatSet");

    QTest::addColumn<bool>("isOneOfDogValid");

    QTest::addColumn<bool>("isOneOfDogSet");

    QTest::addColumn<bool>("isValid");

    QTest::addColumn<bool>("isSet");

    SchemasModelsOneOf::Pet pet;

    QTest::newRow("Empty Pet object")

        // pet                         // expectedJson

        << pet                         << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOfCatExpectedJson        // oneOfDogExpectedJson

        << QString("{}"_L1)            << QString("{}"_L1)

        // getOneOfCat                 // getOneOfDog

        << SchemasModelsOneOf::Cat()   << SchemasModelsOneOf::Dog()

        // isOneOfCatValid             // isOneOfCatSet

        << false                       << false

        // isOneOfDogValid             // isOneOfDogSet

        << false                       << false

        // isValid                     // isSet

        << false                       << false;

    SchemasModelsOneOf::Cat kitty;

    kitty.setHunts(false);

    kitty.setAge(7);

    SchemasModelsOneOf::Dog hund;

    hund.setBark(false);

    hund.setBreed("French Bulldog"_L1);

    // check setters work fine

    pet.setOneOfCat(kitty);

    QTest::newRow("Set a valid Cat object via setter")

        // pet                         // expectedJson

        << pet                         << kitty.asJson()

        // expectedJsonValue

        << kitty.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << QString("{\"age\":7,\"hunts\":false}"_L1)  << QString("{}"_L1)

        // getOneOfCat                                // getOneOfDog

        << kitty                                      << SchemasModelsOneOf::Dog()

        // isOneOfCatValid                            // isOneOfCatSet

        << true                                       << true

        // isOneOfDogValid                            // isOneOfDogSet

        << false                                      << false

        // isValid                                    // isSet

        << true                                       << true;

    // Dog has required field bark, so empty Dog is invalid

    pet.setOneOfDog(hund);

    QTest::newRow("Set a valid Dog object via setter")

        // pet                                        // expectedJson

        << pet                                        << hund.asJson()

        // expectedJsonValue

        << hund.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << QString("{}"_L1)                           << QString("{\"bark\":false,\"breed\":\"French Bulldog\"}"_L1)

        // getOneOfCat                                // getOneOfDog

        << SchemasModelsOneOf::Cat()                  << hund

        // isOneOfCatValid                            // isOneOfCatSet

        << false                                      << false

        // isOneOfDogValid                            // isOneOfDogSet

        << true                                       << true

        // isValid                                    // isSet

        << true                                       << true;

    // Set an empty Dog object, the dog has required fields, so an empty

    // dog is INVALID => entire Pet stays invalid

    const SchemasModelsOneOf::Dog emptyDog;

    pet.setOneOfDog(emptyDog);

    QTest::newRow("Set an empty Dog object via setter")

        // pet                                        // expectedJson

        << pet                                        << emptyDog.asJson()

        // expectedJsonValue

        << emptyDog.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << QString("{}"_L1)                           << QString("{}"_L1)

        // getOneOfCat                                // getOneOfDog

        << SchemasModelsOneOf::Cat()                  << emptyDog

        // isOneOfCatValid                            // isOneOfCatSet

        << false                                      << false

        // isOneOfDogValid                            // isOneOfDogSet

        << false                                      << false

        // isValid                                    // isSet

        << false                                      << false;

    // Set an empty Cat object, the cat has no required fields, so an empty

    // cat is VALID => entire Pet becomes valid

    const SchemasModelsOneOf::Cat emptyCat;

    pet.setOneOfCat(emptyCat);

    QTest::newRow("Set an empty Cat object via setter")

        // pet                                        // expectedJson

        << pet                                        << emptyCat.asJson()

        // expectedJsonValue

        << emptyCat.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << QString("{}"_L1)                           << QString("{}"_L1)

        // getOneOfCat                                // getOneOfDog

        << emptyCat                                   << emptyDog

        // isOneOfCatValid                            // isOneOfCatSet

        << true                                       << true

        // isOneOfDogValid                            // isOneOfDogSet

        << false                                      << false

        // isValid                                    // isSet

        << true                                       << true;

    // fromJsonValue with EMPTY data.

    // Attempting to set an empty Dog via pet.fromJsonValue().

    // Dog defines required fields, so an empty object is INVALID for Dog.

//

    // However, emptyDog.asJsonValue() produces '{}' because it is an empty object.

//

    // The Pet::fromJsonValue() logic cannot determine whether '{}' represents

    // a Cat or a Dog. The only available approach is to try deserializing '{}'

    // against each schema and select the one that validates successfully.

//

    // This leads to ambiguity, since '{}' is a valid Cat instance.

//

    // To avoid such situations, the schema should define either a discriminator

    // or required fields for each Object in the YAML specification.

//

    // This ambiguity is intentional here for testing purposes, to highlight

    // the importance of well-defined API schemas. Ensuring correctness of the

    // API design is the responsibility of the API author.

    pet.fromJsonValue(emptyDog.asJsonValue());

    QTest::newRow("Set an empty Dog via ::fromJsonValue(emptyDog.asJsonValue())")

        // pet                                        // expectedJson

        << pet                                        << emptyDog.asJson()

        // expectedJsonValue

        << emptyDog.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << QString("{}"_L1)                           << QString("{}"_L1)

        // getOneOfCat                                // getOneOfDog

        << emptyCat                                   << emptyDog

        // !!! NOTE: ambiguity is here, cat is VALID!

        // isOneOfCatValid                            // isOneOfCatSet

        << true                                       << true

        // isOneOfDogValid                            // isOneOfDogSet

        << false                                      << false

        // isValid                                    // isSet

        << true                                       << true;

    // fromJson with EMPTY data.

    // Same expectations like with

    // 'Set an empty Dog via pet.fromJsonValue(emptyDog.asJsonValue())'

    pet.fromJson(emptyDog.asJson());

    QTest::newRow("Set an empty Dog via ::fromJson(emptyDog.asJson())")

        // pet                                        // expectedJson

        << pet                                        << emptyDog.asJson()

        // expectedJsonValue

        << emptyDog.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << QString("{}"_L1)                           << QString("{}"_L1)

        // getOneOfCat                                // getOneOfDog

        << emptyCat                                   << emptyDog

        // !!! NOTE: ambiguity is here, cat is VALID!

        // isOneOfCatValid                            // isOneOfCatSet

        << true                                       << true

        // isOneOfDogValid                            // isOneOfDogSet

        << false                                      << false

        // isValid                                    // isSet

        << true                                       << true;

    // fromJson with EMPTY data.

    // Same expectations like with

    // 'Set an empty Dog via pet.fromJsonValue(emptyDog.asJsonValue())'

    pet.fromJson(emptyCat.asJson());

    QTest::newRow("Set an empty Cat via ::fromJson(emptyCat.asJson())")

        // pet                                        // expectedJson

        << pet                                        << emptyCat.asJson()

        // expectedJsonValue

        << emptyCat.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << QString("{}"_L1)                           << QString("{}"_L1)

        // getOneOfCat                                // getOneOfDog

        << emptyCat                                   << emptyDog

        // isOneOfCatValid                            // isOneOfCatSet

        << true                                       << true

        // isOneOfDogValid                            // isOneOfDogSet

        << false                                      << false

        // isValid                                    // isSet

        << true                                       << true;

    pet.fromJsonValue(emptyCat.asJsonValue());

    QTest::newRow("Set an empty Cat via ::fromJsonValue(emptyCat.asJsonValue())")

        // pet                                        // expectedJson

        << pet                                        << emptyCat.asJson()

        // expectedJsonValue

        << emptyCat.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << QString("{}"_L1)                           << QString("{}"_L1)

        // getOneOfCat                                // getOneOfDog

        << emptyCat                                   << emptyDog

        // isOneOfCatValid                            // isOneOfCatSet

        << true                                       << true

        // isOneOfDogValid                            // isOneOfDogSet

        << false                                      << false

        // isValid                                    // isSet

        << true                                       << true;

    // check fromJson() works fine for VALID cat object

    const QString kittyCat("{\"age\":90,\"hunts\":false}"_L1);

    pet.fromJson(kittyCat);

    QTest::newRow("Set a valid Cat object via ::fromJson()")

        // pet                                        // expectedJson

        << pet                                        << kittyCat

        // expectedJsonValue

        << pet.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << kittyCat                                   << QString("{}"_L1)

        // getOneOfCat                                // getOneOfDog

        << SchemasModelsOneOf::Cat(kittyCat)          << emptyDog

        // isOneOfCatValid                            // isOneOfCatSet

        << true                                       << true

        // isOneOfDogValid                            // isOneOfDogSet

        << false                                      << false

        // isValid                                    // isSet

        << true                                       << true;

    // check fromJsonValue() works fine for VALID cat object

    const SchemasModelsOneOf::Cat okCat(kittyCat);

    pet.fromJsonValue(okCat.asJsonValue());

    QTest::newRow("Set a valid Cat object via ::fromJsonValue()")

        // pet                                        // expectedJson

        << pet                                        << kittyCat

        // expectedJsonValue

        << pet.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << kittyCat                                   << QString("{}"_L1)

        // getOneOfCat                                // getOneOfDog

        << SchemasModelsOneOf::Cat(kittyCat)          << emptyDog

        // isOneOfCatValid                            // isOneOfCatSet

        << true                                       << true

        // isOneOfDogValid                            // isOneOfDogSet

        << false                                      << false

        // isValid                                    // isSet

        << true                                       << true;

    // check fromJson() works fine for VALID cat object

    const QString doggyDog("{\"bark\":false,\"breed\":\"French Bulldog\"}"_L1);

    pet.fromJson(doggyDog);

    QTest::newRow("Set a valid Dog object via ::fromJson()")

        // pet                                        // expectedJson

        << pet                                        << doggyDog

        // expectedJsonValue

        << pet.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << QString("{}"_L1)                           << doggyDog

        // getOneOfCat                                // getOneOfDog

        << emptyCat                                   << SchemasModelsOneOf::Dog(doggyDog)

        // isOneOfCatValid                            // isOneOfCatSet

        << false                                      << false

        // isOneOfDogValid                            // isOneOfDogSet

        << true                                       << true

        // isValid                                    // isSet

        << true                                       << true;

    // check fromJsonValue() works fine for VALID cat object

    const SchemasModelsOneOf::Dog okDog(doggyDog);

    pet.fromJsonValue(okDog.asJsonValue());

    QTest::newRow("Set a valid Dog object via ::fromJsonValue()")

        // pet                                        // expectedJson

        << pet                                        << doggyDog

        // expectedJsonValue

        << pet.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << QString("{}"_L1)                           << doggyDog

        // getOneOfCat                                // getOneOfDog

        << emptyCat                                   << okDog

        // isOneOfCatValid                            // isOneOfCatSet

        << false                                      << false

        // isOneOfDogValid                            // isOneOfDogSet

        << true                                       << true

        // isValid                                    // isSet

        << true                                       << true;

    // invalid json!

    pet.fromJson("{invalid json}"_L1);

    QTest::newRow("Set an invalid json via ::fromJson()")

        // pet                                        // expectedJson

        << pet                                        << QString("{}"_L1)

        // expectedJsonValue

        << pet.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << QString("{}"_L1)                           << QString("{}"_L1)

        // getOneOfCat                                // getOneOfDog

        << emptyCat                                   << emptyDog

        // isOneOfCatValid                            // isOneOfCatSet

        << false                                      << false

        // isOneOfDogValid                            // isOneOfDogSet

        << false                                      << false

        // isValid                                    // isSet

        << false                                      << false;

    // Test with non-object JSON (array)

    pet.fromJson("[]"_L1);

    QTest::newRow("Set an unexpected array [] via ::fromJson()")

        // pet                                        // expectedJson

        << pet                                        << QString("{}"_L1)

        // expectedJsonValue

        << pet.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << QString("{}"_L1)                           << QString("{}"_L1)

        // getOneOfCat                                // getOneOfDog

        << emptyCat                                   << emptyDog

        // isOneOfCatValid                            // isOneOfCatSet

        << false                                      << false

        // isOneOfDogValid                            // isOneOfDogSet

        << false                                      << false

        // isValid                                    // isSet

        << false                                      << false;

    // Test with non-object JSON (string)

    pet.fromJson("\"just a string\""_L1);

    QTest::newRow("Set an unexpected string via ::fromJson()")

        // pet                                        // expectedJson

        << pet                                        << QString("{}"_L1)

        // expectedJsonValue

        << pet.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << QString("{}"_L1)                           << QString("{}"_L1)

        // getOneOfCat                                // getOneOfDog

        << emptyCat                                   << emptyDog

        // isOneOfCatValid                            // isOneOfCatSet

        << false                                      << false

        // isOneOfDogValid                            // isOneOfDogSet

        << false                                      << false

        // isValid                                    // isSet

        << false                                      << false;

    // Missing Required Fields (Dog's 'bark' is required)

    // Dog without required 'bark' field - should not be valid

    SchemasModelsOneOf::Dog invalidDog;

    invalidDog.setBreed("Husky-kolbasky"_L1);

    pet.setOneOfDog(invalidDog);

    QTest::newRow("Set an invalid Dog via setter")

        // pet                                        // expectedJson

        << pet                                        << QString("{}"_L1)

        // expectedJsonValue

        << pet.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << QString("{}"_L1)                           << QString("{\"breed\":\"Husky-kolbasky\"}"_L1)

        // getOneOfCat                                // getOneOfDog

        << emptyCat                                   << invalidDog

        // isOneOfCatValid                            // isOneOfCatSet

        << false                                      << false

        // The status here reflects the status of the model that was set.

        // The model's field was set by setter, so invalidDog.isSet() == true

        // but invalidDog.isValid() == false, because required field is not set.

        // isOneOfDogValid                            // isOneOfDogSet

        << invalidDog.isValid()                       << invalidDog.isSet()

        // isValid                                    // isSet

        << false                                      << true;

    // Try to parse JSON missing required field, the dog is invalid.

    pet.fromJson("{\"breed\":\"Retriever\"}"_L1);

    QTest::newRow("Set an invalid Dog via ::fromJson()")

        // pet                                        // expectedJson

        << pet                                        << QString("{}"_L1)

        // expectedJsonValue

        << pet.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << QString("{}"_L1)                           << QString("{\"breed\":\"Retriever\"}"_L1)

        // getOneOfCat                                // getOneOfDog

        << emptyCat                                   << SchemasModelsOneOf::Dog("{\"breed\":\"Retriever\"}"_L1)

        // isOneOfCatValid                            // isOneOfCatSet

        << false                                      << false

        // isOneOfDogValid                            // isOneOfDogSet

        << false                                      << true

        // isValid                                    // isSet

        << false                                      << true;

    // Partial/Incomplete JSON Objects

    // Only one field for Cat (age without hunts),

    // should work since Cat has no required fields

    const QString notFullCat("{\"age\":5}"_L1);

    pet.fromJson(notFullCat);

    QTest::newRow("Set a valid non-full Cat via ::fromJson()")

        // pet                                        // expectedJson

        << pet                                        << notFullCat

        // expectedJsonValue

        << pet.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << notFullCat                                 << QString("{}"_L1)

        // getOneOfCat                                // getOneOfDog

        << SchemasModelsOneOf::Cat("{\"age\":5}"_L1)  << emptyDog

        // isOneOfCatValid                            // isOneOfCatSet

        << true                                       << true

        // isOneOfDogValid                            // isOneOfDogSet

        << false                                      << false

        // isValid                                    // isSet

        << true                                       << true;

    // Extra/Unknown Fields in JSON

    // JSON with fields not in schema - should parse known fields and ignore unknown

    pet.fromJson("{\"age\":7,\"hunts\":false,\"name\":\"Fluffy\",\"color\":\"orange\"}"_L1);

    QString expected("{\"age\":7,\"hunts\":false}"_L1);

    QTest::newRow("Extra/Unknown Fields in JSON via ::fromJson()")

        // pet                                        // expectedJson

        << pet                                        << expected

        // expectedJsonValue

        << pet.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << expected                                   << QString("{}"_L1)

        // getOneOfCat                                // getOneOfDog

        << SchemasModelsOneOf::Cat(expected)          << emptyDog

        // isOneOfCatValid                            // isOneOfCatSet

        << true                                       << true

        // isOneOfDogValid                            // isOneOfDogSet

        << false                                      << false

        // isValid                                    // isSet

        << true                                       << true;

    // Empty Strings in Fields

    expected = QString("{\"bark\":true,\"breed\":\"\"}"_L1);

    pet.fromJson(expected);

    QTest::newRow("An empty String in Dog breed field via ::fromJson()")

        // pet                                        // expectedJson

        << pet                                        << expected

        // expectedJsonValue

        << pet.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << QString("{}"_L1)                           << expected

        // getOneOfCat                                // getOneOfDog

        << emptyCat                                   << SchemasModelsOneOf::Dog(expected)

        // isOneOfCatValid                            // isOneOfCatSet

        << false                                      << false

        // isOneOfDogValid                            // isOneOfDogSet

        << true                                       << true

        // isValid                                    // isSet

        << true                                       << true;

    // Invalid Field Types for Cat(). Wrong type for age (string instead of integer)

    // Note: field of Cat type are not required, it means wrong fields can be omitted

    expected = QString("{\"age\":\"seven\",\"hunts\":false}"_L1);

    pet.fromJson(expected);

    QTest::newRow("Invalid field 'age=seven' in Cat via ::fromJson()")

        // pet                                        // expectedJson

        << pet                                        << QString("{\"hunts\":false}"_L1)

        // expectedJsonValue

        << pet.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << QString("{\"hunts\":false}"_L1)            << QString("{}"_L1)

        // getOneOfCat                                // getOneOfDog

        << SchemasModelsOneOf::Cat(expected)          << emptyDog

        // isOneOfCatValid                            // isOneOfCatSet

        << true                                       << true

        // isOneOfDogValid                            // isOneOfDogSet

        << false                                      << false

        // isValid                                    // isSet

        << true                                       << true;

    // Invalid Field Types for Cat(). Wrong type for age (double instead of integer)

    // Note: field of Cat type are not required, it means wrong fields can be omitted

    expected = QString("{\"age\":0.1,\"hunts\":true}"_L1);

    pet.fromJson(expected);

    QTest::newRow("Invalid field 'age=0.1' in Cat via ::fromJson()")

        // pet                                        // expectedJson

        << pet                                        << QString("{\"hunts\":true}"_L1)

        // expectedJsonValue

        << pet.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << QString("{\"hunts\":true}"_L1)             << QString("{}"_L1)

        // getOneOfCat                                // getOneOfDog

        << SchemasModelsOneOf::Cat(expected)          << emptyDog

        // isOneOfCatValid                            // isOneOfCatSet

        << true                                       << true

        // isOneOfDogValid                            // isOneOfDogSet

        << false                                      << false

        // isValid                                    // isSet

        << true                                       << true;

    // Invalid Field Types in for Cat(). Wrong type for age (bool instead of integer)

    // Note: field of Cat type are not required, it means wrong fields can be omitted

    expected = QString("{\"age\":true,\"hunts\":true}"_L1);

    pet.fromJson(expected);

    QTest::newRow("Invalid field 'age=true' in Cat via ::fromJson()")

        // pet                                        // expectedJson

        << pet                                        << QString("{\"hunts\":true}"_L1)

        // expectedJsonValue

        << pet.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << QString("{\"hunts\":true}"_L1)             << QString("{}"_L1)

        // getOneOfCat                                // getOneOfDog

        << SchemasModelsOneOf::Cat(expected)          << emptyDog

        // isOneOfCatValid                            // isOneOfCatSet

        << true                                       << true

        // isOneOfDogValid                            // isOneOfDogSet

        << false                                      << false

        // isValid                                    // isSet

        << true                                       << true;

    expected = QString("{\"age\":true,\"hunts\":1}"_L1);

    pet.fromJson(expected);

    QTest::newRow("Invalid fields: 'age=true', hunts=1 in Cat via ::fromJson()")

        // pet                                        // expectedJson

        << pet                                        << QString("{}"_L1)

        // expectedJsonValue

        << pet.asJsonValue()

        // oneOfCatExpectedJson                       // oneOfDogExpectedJson

        << QString("{}"_L1)                           << QString("{}"_L1)

        // getOneOfCat                                // getOneOfDog

        << emptyCat                                   << emptyDog

        // isOneOfCatValid                            // isOneOfCatSet

        << false                                      << false

        // isOneOfDogValid                            // isOneOfDogSet

        << false                                      << false

        // isValid                                    // isSet

        << false                                      << false;

void OneOfTest::testAlternativeSchemasFunctions()

    QFETCH(SchemasModelsOneOf::Pet, pet);

    QFETCH(QString, expectedJson);

    QFETCH(QJsonValue, expectedJsonValue);

    QFETCH(QString, oneOfCatExpectedJson);

    QFETCH(QString, oneOfDogExpectedJson);

    QFETCH(SchemasModelsOneOf::Cat, getOneOfCat);

    QFETCH(SchemasModelsOneOf::Dog, getOneOfDog);

    QFETCH(bool, isOneOfCatValid);

    QFETCH(bool, isOneOfCatSet);

    QFETCH(bool, isOneOfDogValid);

    QFETCH(bool, isOneOfDogSet);

    QFETCH(bool, isValid);

    QFETCH(bool, isSet);

    QCOMPARE(pet.asJson(), expectedJson);

    QCOMPARE(pet.asJsonValue(), expectedJsonValue);

    QCOMPARE(pet.getOneOfCat().asJson(), oneOfCatExpectedJson);

    QCOMPARE(pet.isOneOfCatValid(), isOneOfCatValid);

    QCOMPARE(pet.isOneOfCatSet(), isOneOfCatSet);

    QCOMPARE(pet.getOneOfDog().asJson(), oneOfDogExpectedJson);

    QCOMPARE(pet.getOneOfCat(), getOneOfCat);

    QCOMPARE(pet.getOneOfDog(), getOneOfDog);

    QCOMPARE(pet.isOneOfDogValid(), isOneOfDogValid);

    QCOMPARE(pet.isOneOfDogSet(), isOneOfDogSet);

    QCOMPARE(pet.isValid(), isValid);

    QCOMPARE(pet.isSet(), isSet);

void OneOfTest::testAlternativeSchemasOptional_data()

    generateAlternativeSchemasTestData();

void OneOfTest::testAlternativeSchemasOptional()

    QFETCH(SchemasModelsOneOf::Pet, pet);

    QFETCH(SchemasModelsOneOf::Cat, cat);

    QFETCH(SchemasModelsOneOf::Dog, dog);

    QFETCH(OneOfTest::StoreApiMode, mode);

    QFETCH(QString, expectedJson);

    bool done = true;

    SchemasModelsOneOf::StoreApi api;

    LoggingNetworkAccessManager logging(&api);

    QRestAccessManager restManager(&logging, &api);

    api.setRestAccessManager(&restManager);

    switch (mode) {

    case OneOfTest::StoreApiMode::UseCat:

        api.postPetData(QtOpenApiCommon::OptionalParameter<SchemasModelsOneOf::Pet>(cat),

                        this, [&](const QRestReply &reply) {

                            done = reply.isSuccess();

});

    } break;

    case OneOfTest::StoreApiMode::UseDog:

        api.postPetData(QtOpenApiCommon::OptionalParameter<SchemasModelsOneOf::Pet>(dog),

                        this, [&](const QRestReply &reply) {

                            done = reply.isSuccess();

});

    } break;

    case OneOfTest::StoreApiMode::UsePet:

        api.postPetData(pet, this, [&](const QRestReply &reply) {

            done = reply.isSuccess();

});

    } break;

    QCOMPARE(logging.m_content, expectedJson);

    QTRY_COMPARE_EQ(done, false);

void OneOfTest::generateAlternativeSchemasTestData()

    QTest::addColumn<SchemasModelsOneOf::Pet>("pet");

    QTest::addColumn<SchemasModelsOneOf::Cat>("cat");

    QTest::addColumn<SchemasModelsOneOf::Dog>("dog");

    QTest::addColumn<OneOfTest::StoreApiMode>("mode");

    QTest::addColumn<QString>("expectedJson");

    QTest::newRow("empty")

        << SchemasModelsOneOf::Pet{}

        << SchemasModelsOneOf::Cat{}

        << SchemasModelsOneOf::Dog{}

        << OneOfTest::StoreApiMode::UsePet

        << QString("{}"_L1);

    SchemasModelsOneOf::Pet pet;

    SchemasModelsOneOf::Cat kitty;

    kitty.setHunts(true);

    kitty.setAge(7);

    SchemasModelsOneOf::Dog hund;

    hund.setBark(false);

    hund.setBreed("Labrador"_L1);

    QTest::newRow("Use Cat object")

        << SchemasModelsOneOf::Pet{}

        << kitty

        << SchemasModelsOneOf::Dog{}

        << OneOfTest::StoreApiMode::UseCat

        << QString("{\"age\":7,\"hunts\":true}"_L1);

    QTest::newRow("Use Dog object")

        << SchemasModelsOneOf::Pet{}

        << SchemasModelsOneOf::Cat{}

        << hund

        << OneOfTest::StoreApiMode::UseDog

        << QString("{\"bark\":false,\"breed\":\"Labrador\"}"_L1);

    // Setting the cat the pet()

    kitty.setAge(9);

    pet.setOneOfCat(kitty);

    QTest::newRow("Set the cat data to a pet object")

        << pet

        << SchemasModelsOneOf::Cat{}

        << SchemasModelsOneOf::Dog{}

        << OneOfTest::StoreApiMode::UsePet

        << QString("{\"age\":9,\"hunts\":true}"_L1);

    hund.setBark(true);

    pet.setOneOfDog(hund);

    QTest::newRow("Set the dog data to a pet object")

        << pet

        << SchemasModelsOneOf::Cat{}

        << SchemasModelsOneOf::Dog{}

        << OneOfTest::StoreApiMode::UsePet

        << QString("{\"bark\":true,\"breed\":\"Labrador\"}"_L1);

    pet.setOneOfDog(SchemasModelsOneOf::Dog());

    QTest::newRow("Reset the pet data to an empty Dog()")

        << pet

        << SchemasModelsOneOf::Cat{}

        << SchemasModelsOneOf::Dog{}

        << OneOfTest::StoreApiMode::UsePet

        << QString("{}"_L1);

    SchemasModelsOneOf::Dog invalidDog;

    invalidDog.setBreed("Unknown"_L1);

    QTest::newRow("Construct the dog without setting the `required` field(bark)")

        << SchemasModelsOneOf::Pet{}

        << SchemasModelsOneOf::Cat{}

        << invalidDog

        << OneOfTest::StoreApiMode::UseDog

        // It's empty because the object is not valid, without setting the required field

        << QString("{}"_L1);

    // Construct the cat but skipping some fields.

    // NOTE: Cat type doesn't have `required` fields,

    // so it will not be empty.

    SchemasModelsOneOf::Cat cat;

    cat.setAge(5);

    QTest::newRow("Construct the cat with only age field set")

        << SchemasModelsOneOf::Pet{}

        << cat

        << SchemasModelsOneOf::Dog{}

        << OneOfTest::StoreApiMode::UseCat

        << QString("{\"age\":5}"_L1);

void OneOfTest::testAlternativeSchemasRequired_data()

    generateAlternativeSchemasTestData();

void OneOfTest::testAlternativeSchemasRequired()

    QFETCH(SchemasModelsOneOf::Pet, pet);

    QFETCH(SchemasModelsOneOf::Cat, cat);

    QFETCH(SchemasModelsOneOf::Dog, dog);

    QFETCH(OneOfTest::StoreApiMode, mode);

    QFETCH(QString, expectedJson);

    bool done = true;

    SchemasModelsOneOf::StoreApi api;

    LoggingNetworkAccessManager logging(&api);

    QRestAccessManager restManager(&logging, &api);

    api.setRestAccessManager(&restManager);

    switch (mode) {

    case OneOfTest::StoreApiMode::UseCat:

        api.patchPetData(cat, this, [&](const QRestReply &reply) {

            done = reply.isSuccess();

});

    } break;

    case OneOfTest::StoreApiMode::UseDog:

        api.patchPetData(dog, this, [&](const QRestReply &reply) {

            done = reply.isSuccess();

});

    } break;

    case OneOfTest::StoreApiMode::UsePet:

        api.patchPetData(pet, this, [&](const QRestReply &reply) {

            done = reply.isSuccess();

});

    } break;

    QCOMPARE(logging.m_content, expectedJson);

    QTRY_COMPARE_EQ(done, false);

void OneOfTest::testClientValueJsonConversionMethods_data()

    QTest::addColumn<SchemasModelsOneOf::Client_value>("clientValue");

    QTest::addColumn<QString>("expectedJson");

    QTest::addColumn<QJsonValue>("expectedJsonValue");

    QTest::addColumn<QString>("oneOf0ExpectedValue");

    QTest::addColumn<bool>("oneOf1ExpectedValue");

    QTest::addColumn<bool>("isOneOf0Valid");

    QTest::addColumn<bool>("isOneOf0Set");

    QTest::addColumn<bool>("isOneOf1Valid");

    QTest::addColumn<bool>("isOneOf1Set");

    QTest::addColumn<bool>("isValid");

    QTest::addColumn<bool>("isSet");

    // Client_value has two primitive oneOf alternatives:

    // oneOf0: string - always valid

    // oneOf1: boolean - always valid

    SchemasModelsOneOf::Client_value clientValue;

    QTest::newRow("Empty Client_value object")

        // clientValue                    // expectedJson

        << clientValue                    << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << QString()                      << false

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Set a string value via setter

    clientValue.setOneOfQString("hello-client"_L1);

    QTest::newRow("Set a valid string via setter")

        // clientValue                    // expectedJson

        << clientValue                    << QString("\"hello-client\""_L1)

        // expectedJsonValue

        << QJsonValue("hello-client"_L1)

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << QString("hello-client"_L1)     << false

        // isOneOf0Valid                  // isOneOf0Set

        << true                           << true

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set a bool 'true' via setter

    clientValue.setOneOfBool(true);

    QTest::newRow("Set a valid bool 'true' via setter")

        // clientValue                    // expectedJson

        << clientValue                    << QString("true"_L1)

        // expectedJsonValue

        << QJsonValue(true)

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << QString()                      << true

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // Set a bool 'false' via setter

    clientValue.setOneOfBool(false);

    QTest::newRow("Set a valid bool 'false' via setter")

        // clientValue                    // expectedJson

        << clientValue                    << QString("false"_L1)

        // expectedJsonValue

        << QJsonValue(false)

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << QString()                      << false

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // Set an empty string via setter

    clientValue.setOneOfQString("");

    QTest::newRow("Set an empty string via setter")

        // clientValue                    // expectedJson

        << clientValue                    << QString("\"\""_L1)

        // expectedJsonValue

        << QJsonValue(""_L1)

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << QString(""_L1)                 << false

        // isOneOf0Valid                  // isOneOf0Set

        << true                           << true

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson with a string value

    clientValue.fromJson("\"client-data\""_L1);

    QTest::newRow("Set a valid string via ::fromJson()")

        // clientValue                    // expectedJson

        << clientValue                    << QString("\"client-data\""_L1)

        // expectedJsonValue

        << QJsonValue("client-data"_L1)

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << QString("client-data"_L1)      << false

        // isOneOf0Valid                  // isOneOf0Set

        << true                           << true

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson with a bool 'true' value

    clientValue.fromJson("true"_L1);

    QTest::newRow("Set a valid bool 'true' via ::fromJson()")

        // clientValue                    // expectedJson

        << clientValue                    << QString("true"_L1)

        // expectedJsonValue

        << QJsonValue(true)

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << QString()                      << true

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // fromJson with a bool 'false' value

    clientValue.fromJson("false"_L1);

    QTest::newRow("Set a valid bool 'false' via ::fromJson()")

        // clientValue                    // expectedJson

        << clientValue                    << QString("false"_L1)

        // expectedJsonValue

        << QJsonValue(false)

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << QString()                      << false

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue with string

    clientValue.fromJsonValue(QJsonValue("via-json-value"_L1));

    QTest::newRow("Set a valid string via ::fromJsonValue()")

        // clientValue                    // expectedJson

        << clientValue                    << QString("\"via-json-value\""_L1)

        // expectedJsonValue

        << QJsonValue("via-json-value"_L1)

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << QString("via-json-value"_L1)   << false

        // isOneOf0Valid                  // isOneOf0Set

        << true                           << true

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue with bool

    clientValue.fromJsonValue(QJsonValue(true));

    QTest::newRow("Set a valid bool 'true' via ::fromJsonValue()")

        // clientValue                    // expectedJson

        << clientValue                    << QString("true"_L1)

        // expectedJsonValue

        << QJsonValue(true)

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << QString()                      << true

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // invalid json! => the model is RESET to INITIAL state

    clientValue.fromJson("{invalid json}"_L1);

    QTest::newRow("Set an invalid json via ::fromJson()")

        // clientValue                    // expectedJson

        << clientValue                    << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << QString()                      << false

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Test with non-primitive JSON (object) => doesn't match string or bool

    clientValue.fromJson("{\"key\":\"value\"}"_L1);

    QTest::newRow("Set an unexpected object via ::fromJson()")

        // clientValue                    // expectedJson

        << clientValue                    << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << QString()                      << false

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Test with array JSON => doesn't match string or bool

    clientValue.fromJson("[1, 2]"_L1);

    QTest::newRow("Client_value: set an unexpected array via ::fromJson()")

        // clientValue                    // expectedJson

        << clientValue                    << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << QString()                      << false

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Test with null JSON => doesn't match string or bool

    clientValue.fromJson("null"_L1);

    QTest::newRow("Set a null value via ::fromJson()")

        // clientValue                    // expectedJson

        << clientValue                    << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << QString()                      << false

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Test with number JSON => doesn't match string or bool

    clientValue.fromJson("42"_L1);

    QTest::newRow("Set an unexpected number via ::fromJson()")

        // clientValue                    // expectedJson

        << clientValue                    << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << QString()                      << false

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // fromJson with a string that looks like a bool (but is quoted => string)

    clientValue.fromJson("\"true\""_L1);

    QTest::newRow("Set a string 'true' (quoted) via ::fromJson()")

        // clientValue                    // expectedJson

        << clientValue                    << QString("\"true\""_L1)

        // expectedJsonValue

        << QJsonValue("true"_L1)

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << QString("true"_L1)             << false

        // isOneOf0Valid                  // isOneOf0Set

        << true                           << true

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson with a string that looks like a number (but is quoted => string)

    clientValue.fromJson("\"42\""_L1);

    QTest::newRow("Set a string '42' (quoted) via ::fromJson()")

        // clientValue                    // expectedJson

        << clientValue                    << QString("\"42\""_L1)

        // expectedJsonValue

        << QJsonValue("42"_L1)

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << QString("42"_L1)               << false

        // isOneOf0Valid                  // isOneOf0Set

        << true                           << true

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Override string with bool via setter

    clientValue.setOneOfQString("will be overridden"_L1);

    clientValue.setOneOfBool(true);

    QTest::newRow("Override string with bool via setter")

        // clientValue                    // expectedJson

        << clientValue                    << QString("true"_L1)

        // expectedJsonValue

        << QJsonValue(true)

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << QString()                      << true

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // Override bool with string via setter

    clientValue.setOneOfBool(false);

    clientValue.setOneOfQString("override-back"_L1);

    QTest::newRow("Override bool with string via setter")

        // clientValue                    // expectedJson

        << clientValue                    << QString("\"override-back\""_L1)

        // expectedJsonValue

        << QJsonValue("override-back"_L1)

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << QString("override-back"_L1)    << false

        // isOneOf0Valid                  // isOneOf0Set

        << true                           << true

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // String with special characters

    clientValue.setOneOfQString("line1\nline2\ttab"_L1);

    QTest::newRow("Set a string with special characters via setter")

        // clientValue                    // expectedJson

        << clientValue                    << QString("\"line1\\nline2\\ttab\""_L1)

        // expectedJsonValue

        << QJsonValue("line1\nline2\ttab"_L1)

        // oneOf0ExpectedValue

        << QString("line1\nline2\ttab"_L1)

        // oneOf1ExpectedValue

        << false

        // isOneOf0Valid                  // isOneOf0Set

        << true                           << true

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

void OneOfTest::testClientValueJsonConversionMethods()

    QFETCH(SchemasModelsOneOf::Client_value, clientValue);

    QFETCH(QString, expectedJson);

    QFETCH(QJsonValue, expectedJsonValue);

    QFETCH(QString, oneOf0ExpectedValue);

    QFETCH(bool, oneOf1ExpectedValue);

    QFETCH(bool, isOneOf0Valid);

    QFETCH(bool, isOneOf0Set);

    QFETCH(bool, isOneOf1Valid);

    QFETCH(bool, isOneOf1Set);

    QFETCH(bool, isValid);

    QFETCH(bool, isSet);

    QCOMPARE(clientValue.asJson(), expectedJson);

    QCOMPARE(clientValue.asJsonValue(), expectedJsonValue);

    QCOMPARE(clientValue.getOneOfQString(), oneOf0ExpectedValue);

    QCOMPARE(clientValue.isOneOfQStringValid(), isOneOf0Valid);

    QCOMPARE(clientValue.isOneOfQStringSet(), isOneOf0Set);

    QCOMPARE(clientValue.getOneOfBool(), oneOf1ExpectedValue);

    QCOMPARE(clientValue.isOneOfBoolValid(), isOneOf1Valid);

    QCOMPARE(clientValue.isOneOfBoolSet(), isOneOf1Set);

    QCOMPARE(clientValue.isValid(), isValid);

    QCOMPARE(clientValue.isSet(), isSet);

void OneOfTest::testCustomerJsonConversionMethods_data()

    QTest::addColumn<SchemasModelsOneOf::PostSearchData_request_customer>("customer");

    QTest::addColumn<QString>("expectedJson");

    QTest::addColumn<QJsonValue>("expectedJsonValue");

    QTest::addColumn<qint32>("oneOf0ExpectedValue");

    QTest::addColumn<QString>("oneOf1ExpectedValue");

    QTest::addColumn<QString>("oneOf2ExpectedJson");

    QTest::addColumn<QString>("oneOf3ExpectedJson");

    QTest::addColumn<bool>("isOneOf0Valid");

    QTest::addColumn<bool>("isOneOf0Set");

    QTest::addColumn<bool>("isOneOf1Valid");

    QTest::addColumn<bool>("isOneOf1Set");

    QTest::addColumn<bool>("isOneOf2Valid");

    QTest::addColumn<bool>("isOneOf2Set");

    QTest::addColumn<bool>("isOneOf3Valid");

    QTest::addColumn<bool>("isOneOf3Set");

    QTest::addColumn<bool>("isValid");

    QTest::addColumn<bool>("isSet");

    // PostSearchData_request_customer has 4 oneOf alternatives:

    // oneOf0: qint32 (customer ID) - primitive, always valid

    // oneOf1: QString (phone number) - primitive, always valid

    // oneOf2: PostSearchData_request_customer_oneOf (userName REQUIRED, channel optional)

    // oneOf3: PostSearchData_request_customer_oneOf_1 (customerId REQUIRED)

    SchemasModelsOneOf::PostSearchData_request_customer customer;

    QTest::newRow("Empty PostSearchData_request_customer object")

        // customer                       // expectedJson

        << customer                       << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << false                          << false

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Set an integer (customer ID) via setter

    customer.setOneOfQint32(12345);

    QTest::newRow("Set a valid integer (customer ID) via setter")

        // customer                       // expectedJson

        << customer                       << QString("12345"_L1)

        // expectedJsonValue

        << QJsonValue(12345)

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(12345)                  << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << true                           << true

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << false                          << false

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set a string (phone number) via setter

    customer.setOneOfQString("+1234567890"_L1);

    QTest::newRow("Set a valid string (phone number) via setter")

        // customer                       // expectedJson

        << customer                       << QString("\"+1234567890\""_L1)

        // expectedJsonValue

        << QJsonValue("+1234567890"_L1)

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString("+1234567890"_L1)

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << true                           << true

        // isOneOf2Valid                  // isOneOf2Valid

        << false                          << false

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set a valid object with userName (required) via setter

    SchemasModelsOneOf::PostSearchData_request_customer_oneOf userObj;

    userObj.setUserName("john_doe"_L1);

    userObj.setChannel("web"_L1);

    customer.setOneOfPostSearchData_request_customer_oneOf(userObj);

    QTest::newRow("Set a valid userName object via setter")

        // customer                       // expectedJson

        << customer                       << userObj.asJson()

        // expectedJsonValue

        << userObj.asJsonValue()

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << userObj.asJson()               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << true                           << true

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set a valid object with customerId (required) via setter

    SchemasModelsOneOf::PostSearchData_request_customer_oneOf_1 customerIdObj;

    customerIdObj.setCustomerId("CUST-001"_L1);

    customer.setOneOfPostSearchData_request_customer_oneOf_1(customerIdObj);

    QTest::newRow("Set a valid customerId object via setter")

        // customer                       // expectedJson

        << customer                       << customerIdObj.asJson()

        // expectedJsonValue

        << customerIdObj.asJsonValue()

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << QString("{}"_L1)               << customerIdObj.asJson()

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << false                          << false

        // isOneOf3Valid                  // isOneOf3Set

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // Set an empty userName object (missing required userName) => invalid

    SchemasModelsOneOf::PostSearchData_request_customer_oneOf emptyUserObj;

    customer.setOneOfPostSearchData_request_customer_oneOf(emptyUserObj);

    QTest::newRow("Set an empty userName object via setter")

        // customer                       // expectedJson

        << customer                       << emptyUserObj.asJson()

        // expectedJsonValue

        << emptyUserObj.asJsonValue()

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << false                          << false

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Set an empty customerId object (missing required customerId) => invalid

    SchemasModelsOneOf::PostSearchData_request_customer_oneOf_1 emptyCustomerIdObj;

    customer.setOneOfPostSearchData_request_customer_oneOf_1(emptyCustomerIdObj);

    QTest::newRow("Set an empty customerId object via setter")

        // customer                       // expectedJson

        << customer                       << emptyCustomerIdObj.asJson()

        // expectedJsonValue

        << emptyCustomerIdObj.asJsonValue()

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << false                          << false

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Set zero integer via setter (still valid - it's a legitimate value)

    customer.setOneOfQint32(0);

    QTest::newRow("Set zero integer via setter")

        // customer                       // expectedJson

        << customer                       << QString("0"_L1)

        // expectedJsonValue

        << QJsonValue(0)

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << true                           << true

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << false                          << false

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set negative integer via setter

    customer.setOneOfQint32(-42);

    QTest::newRow("Set negative integer via setter")

        // customer                       // expectedJson

        << customer                       << QString("-42"_L1)

        // expectedJsonValue

        << QJsonValue(-42)

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(-42)                    << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << true                           << true

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << false                          << false

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson with an integer value

    customer.fromJson("99999"_L1);

    QTest::newRow("Set a valid integer via ::fromJson()")

        // customer                       // expectedJson

        << customer                       << QString("99999"_L1)

        // expectedJsonValue

        << QJsonValue(99999)

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(99999)                  << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << true                           << true

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << false                          << false

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson with a string value

    customer.fromJson("\"+79001234567\""_L1);

    QTest::newRow("Set a valid phone number string via ::fromJson()")

        // customer                       // expectedJson

        << customer                       << QString("\"+79001234567\""_L1)

        // expectedJsonValue

        << QJsonValue("+79001234567"_L1)

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString("+79001234567"_L1)

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << true                           << true

        // isOneOf2Valid                  // isOneOf2Valid

        << false                          << false

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson with a valid userName object

    const QString validUserJson("{\"channel\":\"mobile\",\"userName\":\"jane_doe\"}"_L1);

    customer.fromJson(validUserJson);

    QTest::newRow("Set a valid userName object via ::fromJson()")

        // customer                       // expectedJson

        << customer                       << validUserJson

        // expectedJsonValue

        << customer.asJsonValue()

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << validUserJson                  << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << true                           << true

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson with a valid customerId object

    const QString validCustIdJson("{\"customerId\":\"CUST-999\"}"_L1);

    customer.fromJson(validCustIdJson);

    QTest::newRow("Set a valid customerId object via ::fromJson()")

        // customer                       // expectedJson

        << customer                       << validCustIdJson

        // expectedJsonValue

        << customer.asJsonValue()

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << QString("{}"_L1)               << validCustIdJson

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << false                          << false

        // isOneOf3Valid                  // isOneOf3Set

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // fromJson with userName object only (without channel - channel is optional)

    const QString userOnlyJson("{\"userName\":\"admin\"}"_L1);

    customer.fromJson(userOnlyJson);

    QTest::newRow("Set userName object without channel via ::fromJson()")

        // customer                       // expectedJson

        << customer                       << userOnlyJson

        // expectedJsonValue

        << customer.asJsonValue()

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << userOnlyJson                   << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << true                           << true

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue with integer

    customer.fromJsonValue(QJsonValue(777));

    QTest::newRow("Set a valid integer via ::fromJsonValue()")

        // customer                       // expectedJson

        << customer                       << QString("777"_L1)

        // expectedJsonValue

        << QJsonValue(777)

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(777)                    << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << true                           << true

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << false                          << false

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue with string

    customer.fromJsonValue(QJsonValue("+4912345"_L1));

    QTest::newRow("Set a valid string via ::fromJsonValue()")

        // customer                       // expectedJson

        << customer                       << QString("\"+4912345\""_L1)

        // expectedJsonValue

        << QJsonValue("+4912345"_L1)

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString("+4912345"_L1)

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << true                           << true

        // isOneOf2Valid                  // isOneOf2Valid

        << false                          << false

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue with valid userName object

    customer.fromJsonValue(userObj.asJsonValue());

    QTest::newRow("Set a valid userName object via ::fromJsonValue()")

        // customer                       // expectedJson

        << customer                       << userObj.asJson()

        // expectedJsonValue

        << customer.asJsonValue()

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << userObj.asJson()               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << true                           << true

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue with valid customerId object

    customer.fromJsonValue(customerIdObj.asJsonValue());

    QTest::newRow("Set a valid customerId object via ::fromJsonValue()")

        // customer                       // expectedJson

        << customer                       << customerIdObj.asJson()

        // expectedJsonValue

        << customer.asJsonValue()

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << QString("{}"_L1)               << customerIdObj.asJson()

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << false                          << false

        // isOneOf3Valid                  // isOneOf3Set

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // invalid json! => the model is RESET to INITIAL state

    customer.fromJson("{invalid json}"_L1);

    QTest::newRow("Set an invalid json via ::fromJson()")

        // customer                       // expectedJson

        << customer                       << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << false                          << false

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Test with array JSON => doesn't match any alternative

    customer.fromJson("[]"_L1);

    QTest::newRow("PostSearchData_request_customer: set an unexpected array via ::fromJson()")

        // customer                       // expectedJson

        << customer                       << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << false                          << false

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // fromJson with empty object "{}" => neither userName nor customerId objects

    // are valid (both have required fields). Does not match int or string either.

    customer.fromJson("{}"_L1);

    QTest::newRow("Set an empty object {} via ::fromJson()")

        // customer                       // expectedJson

        << customer                       << QString("{}"_L1)

        // expectedJsonValue

        << customer.asJsonValue()

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << false                          << false

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // fromJson with a bool value => doesn't match int, string, or objects

    customer.fromJson("true"_L1);

    QTest::newRow("Set an unexpected bool via ::fromJson()")

        // customer                       // expectedJson

        << customer                       << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << false                          << false

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // fromJson with a double value => doesn't match qint32 (not integer)

    customer.fromJson("3.14"_L1);

    QTest::newRow("Set a double via ::fromJson() (no double alternative)")

        // customer                       // expectedJson

        << customer                       << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                           << false

        // isOneOf2Valid                  // isOneOf2Valid

        << false                          << false

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Invalid userName object - missing required userName, has only channel

    customer.fromJson("{\"channel\":\"email\"}"_L1);

    QTest::newRow("Set userName object missing required 'userName' via ::fromJson()")

        // customer                       // expectedJson

        << customer                       << QString("{}"_L1)

        // expectedJsonValue

        << customer.asJsonValue()

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << QString("{\"channel\":\"email\"}"_L1) << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << false                          << true

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << false                          << true;

    // Extra/Unknown Fields in userName object JSON

    customer.fromJson("{\"userName\":\"user1\",\"channel\":\"sms\",\"extra\":\"field\"}"_L1);

    QString expected("{\"channel\":\"sms\",\"userName\":\"user1\"}"_L1);

    QTest::newRow("Extra/Unknown Fields in userName object via ::fromJson()")

        // customer                       // expectedJson

        << customer                       << expected

        // expectedJsonValue

        << customer.asJsonValue()

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << expected                       << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << true                           << true

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set userName object with invalid type for userName field (int instead of string)

    customer.fromJson("{\"userName\":123,\"channel\":\"web\"}"_L1);

    QTest::newRow("Invalid 'userName=123' in userName object via ::fromJson()")

        // customer                       // expectedJson

        << customer                       << QString("{}"_L1)

        // expectedJsonValue

        << customer.asJsonValue()

        // oneOf0ExpectedValue            // oneOf1ExpectedValue

        << qint32(0)                      << QString()

        // oneOf2ExpectedJson             // oneOf3ExpectedJson

        << QString("{\"channel\":\"web\"}"_L1) << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isOneOf2Valid                  // isOneOf2Valid

        << false                          << true

        // isOneOf3Valid                  // isOneOf3Set

        << false                          << false

        // isValid                        // isSet

        << false                          << true;

void OneOfTest::testCustomerJsonConversionMethods()

    QFETCH(SchemasModelsOneOf::PostSearchData_request_customer, customer);

    QFETCH(QString, expectedJson);

    QFETCH(QJsonValue, expectedJsonValue);

    QFETCH(qint32, oneOf0ExpectedValue);

    QFETCH(QString, oneOf1ExpectedValue);

    QFETCH(QString, oneOf2ExpectedJson);

    QFETCH(QString, oneOf3ExpectedJson);

    QFETCH(bool, isOneOf0Valid);

    QFETCH(bool, isOneOf0Set);

    QFETCH(bool, isOneOf1Valid);

    QFETCH(bool, isOneOf1Set);

    QFETCH(bool, isOneOf2Valid);

    QFETCH(bool, isOneOf2Set);

    QFETCH(bool, isOneOf3Valid);

    QFETCH(bool, isOneOf3Set);

    QFETCH(bool, isValid);

    QFETCH(bool, isSet);

    QCOMPARE(customer.asJson(), expectedJson);

    QCOMPARE(customer.asJsonValue(), expectedJsonValue);

    QCOMPARE(customer.getOneOfQint32(), oneOf0ExpectedValue);

    QCOMPARE(customer.isOneOfQint32Valid(), isOneOf0Valid);

    QCOMPARE(customer.isOneOfQint32Set(), isOneOf0Set);

    QCOMPARE(customer.getOneOfQString(), oneOf1ExpectedValue);

    QCOMPARE(customer.isOneOfQStringValid(), isOneOf1Valid);

    QCOMPARE(customer.isOneOfQStringSet(), isOneOf1Set);

    QCOMPARE(customer.getOneOfPostSearchData_request_customer_oneOf().asJson(), oneOf2ExpectedJson);

    QCOMPARE(customer.isOneOfPostSearchDataRequestCustomerOneOfValid(), isOneOf2Valid);

    QCOMPARE(customer.isOneOfPostSearchDataRequestCustomerOneOfSet(), isOneOf2Set);

    QCOMPARE(customer.getOneOfPostSearchData_request_customer_oneOf_1().asJson(), oneOf3ExpectedJson);

    QCOMPARE(customer.isOneOfPostSearchDataRequestCustomerOneOf1Valid(), isOneOf3Valid);

    QCOMPARE(customer.isOneOfPostSearchDataRequestCustomerOneOf1Set(), isOneOf3Set);

    QCOMPARE(customer.isValid(), isValid);

    QCOMPARE(customer.isSet(), isSet);

void OneOfTest::testInlineSchemasJsonConversionMethods_data()

    QTest::addColumn<SchemasModelsOneOf::PostPaymentData_request>("postRequest");

    QTest::addColumn<QString>("expectedJson");

    QTest::addColumn<QJsonValue>("expectedJsonValue");

    QTest::addColumn<QString>("oneOf0ExpectedJson");

    QTest::addColumn<QString>("oneOf1ExpectedJson");

    QTest::addColumn<SchemasModelsOneOf::PostPaymentData_request_oneOf>("getOneOfPostPaymentData_request_oneOf");

    QTest::addColumn<SchemasModelsOneOf::PostPaymentData_request_oneOf_1>("getOneOfPostPaymentData_request_oneOf_1");

    QTest::addColumn<bool>("isOneOfPostPaymentDataRequestOneOfValid");

    QTest::addColumn<bool>("isOneOfPostPaymentDataRequestOneOfSet");

    QTest::addColumn<bool>("isOneOfPostPaymentDataRequestOneOf1Valid");

    QTest::addColumn<bool>("isOneOfPostPaymentDataRequestOneOf1Set");

    QTest::addColumn<bool>("isValid");

    QTest::addColumn<bool>("isSet");

    // PostPaymentData_request has two inline object schemas:

    // oneOf0: PostPaymentData_request_oneOf with cardNumber (string, REQUIRED)

    // and cardAvailability (bool)

    // oneOf1: PostPaymentData_request_oneOf_1 with paypalEmail (string)

    // and paypalAvailability (bool)

    SchemasModelsOneOf::PostPaymentData_request postRequest;

    QTest::newRow("Empty PostPaymentData_request object")

        // postRequest                    // expectedJson

        << postRequest                    << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << SchemasModelsOneOf::PostPaymentData_request_oneOf()

        // getOneOfPostPaymentData_request_oneOf_1

        << SchemasModelsOneOf::PostPaymentData_request_oneOf_1()

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << false

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << false

        // isOneOfPostPaymentDataRequestOneOf1Set

        << false

        // isValid                        // isSet

        << false                          << false;

    // Create valid credit card (oneOf0) - has required 'cardNumber'

    SchemasModelsOneOf::PostPaymentData_request_oneOf creditCard;

    creditCard.setCardNumber("1234-5678-9012-3456"_L1);

    creditCard.setCardAvailability(true);

    // Create valid paypal (oneOf1) - no required fields

    SchemasModelsOneOf::PostPaymentData_request_oneOf_1 paypal;

    paypal.setPaypalEmail("user@example.com"_L1);

    paypal.setPaypalAvailability(true);

    // Set a valid credit card via setter

    postRequest.setOneOfPostPaymentData_request_oneOf(creditCard);

    QTest::newRow("Set a valid CreditCard object via setter")

        // postRequest                    // expectedJson

        << postRequest                    << creditCard.asJson()

        // expectedJsonValue

        << creditCard.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << creditCard.asJson()            << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << creditCard

        // getOneOfPostPaymentData_request_oneOf_1

        << SchemasModelsOneOf::PostPaymentData_request_oneOf_1()

        // isOneOfPostPaymentDataRequestOneOfValid

        << true

        // isOneOfPostPaymentDataRequestOneOfSet

        << true

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << false

        // isOneOfPostPaymentDataRequestOneOf1Set

        << false

        // isValid                        // isSet

        << true                           << true;

    // Set a valid paypal via setter (overrides credit card)

    postRequest.setOneOfPostPaymentData_request_oneOf_1(paypal);

    QTest::newRow("Set a valid Paypal object via setter")

        // postRequest                    // expectedJson

        << postRequest                    << paypal.asJson()

        // expectedJsonValue

        << paypal.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << paypal.asJson()

        // getOneOfPostPaymentData_request_oneOf

        << SchemasModelsOneOf::PostPaymentData_request_oneOf()

        // getOneOfPostPaymentData_request_oneOf_1

        << paypal

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << false

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << true

        // isOneOfPostPaymentDataRequestOneOf1Set

        << true

        // isValid                        // isSet

        << true                           << true;

    // Set an empty CreditCard object. CreditCard has required 'cardNumber',

    // so an empty credit card is INVALID => entire PostPaymentData_request stays invalid

    const SchemasModelsOneOf::PostPaymentData_request_oneOf emptyCreditCard;

    postRequest.setOneOfPostPaymentData_request_oneOf(emptyCreditCard);

    QTest::newRow("Set an empty CreditCard object via setter")

        // postRequest                    // expectedJson

        << postRequest                    << emptyCreditCard.asJson()

        // expectedJsonValue

        << emptyCreditCard.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << emptyCreditCard

        // getOneOfPostPaymentData_request_oneOf_1

        << SchemasModelsOneOf::PostPaymentData_request_oneOf_1()

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << false

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << false

        // isOneOfPostPaymentDataRequestOneOf1Set

        << false

        // isValid                        // isSet

        << false                          << false;

    // Set an empty Paypal object. Paypal has no required fields,

    // so an empty paypal is VALID => entire PostPaymentData_request becomes valid

    const SchemasModelsOneOf::PostPaymentData_request_oneOf_1 emptyPaypal;

    postRequest.setOneOfPostPaymentData_request_oneOf_1(emptyPaypal);

    QTest::newRow("Set an empty Paypal object via setter")

        // postRequest                    // expectedJson

        << postRequest                    << emptyPaypal.asJson()

        // expectedJsonValue

        << emptyPaypal.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << emptyCreditCard

        // getOneOfPostPaymentData_request_oneOf_1

        << emptyPaypal

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << false

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << true

        // isOneOfPostPaymentDataRequestOneOf1Set

        << true

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue with EMPTY data.

    // Attempting to set an empty CreditCard via postRequest.fromJsonValue().

    // CreditCard defines required field 'cardNumber', so an empty object is INVALID

    // for CreditCard.

//

    // However, emptyPaypal.asJsonValue() produces '{}' because it is an empty object.

//

    // The PostPaymentData_request::fromJsonValue() logic cannot determine whether '{}'

    // represents a CreditCard or Paypal. It tries each schema:

    // - CreditCard: INVALID (missing required cardNumber)

    // - Paypal: VALID (no required fields)

//

    // So '{}' resolves to Paypal (oneOf1).

    postRequest.fromJsonValue(emptyCreditCard.asJsonValue());

    QTest::newRow("Set an empty CreditCard via ::fromJsonValue(emptyCreditCard.asJsonValue())")

        // postRequest                    // expectedJson

        << postRequest                    << emptyCreditCard.asJson()

        // expectedJsonValue

        << emptyCreditCard.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << emptyCreditCard

        // getOneOfPostPaymentData_request_oneOf_1

        << emptyPaypal

        // !!! NOTE: ambiguity resolved to Paypal (oneOf1) since CreditCard is invalid

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << false

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << true

        // isOneOfPostPaymentDataRequestOneOf1Set

        << true

        // isValid                        // isSet

        << true                           << true;

    // fromJson with EMPTY data. Same expectations as above.

    postRequest.fromJson(emptyCreditCard.asJson());

    QTest::newRow("Set an empty CreditCard via ::fromJson(emptyCreditCard.asJson())")

        // postRequest                    // expectedJson

        << postRequest                    << emptyCreditCard.asJson()

        // expectedJsonValue

        << emptyCreditCard.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << emptyCreditCard

        // getOneOfPostPaymentData_request_oneOf_1

        << emptyPaypal

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << false

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << true

        // isOneOfPostPaymentDataRequestOneOf1Set

        << true

        // isValid                        // isSet

        << true                           << true;

    // ::fromJson with EMPTY Paypal data. Same expectations.

    postRequest.fromJson(emptyPaypal.asJson());

    QTest::newRow("Set an empty Paypal via ::fromJson(emptyPaypal.asJson())")

        // postRequest                    // expectedJson

        << postRequest                    << emptyPaypal.asJson()

        // expectedJsonValue

        << emptyPaypal.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << emptyCreditCard

        // getOneOfPostPaymentData_request_oneOf_1

        << emptyPaypal

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << false

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << true

        // isOneOfPostPaymentDataRequestOneOf1Set

        << true

        // isValid                        // isSet

        << true                           << true;

    postRequest.fromJsonValue(emptyPaypal.asJsonValue());

    QTest::newRow("Set an empty Paypal via ::fromJsonValue(emptyPaypal.asJsonValue())")

        // postRequest                    // expectedJson

        << postRequest                    << emptyPaypal.asJson()

        // expectedJsonValue

        << emptyPaypal.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << emptyCreditCard

        // getOneOfPostPaymentData_request_oneOf_1

        << emptyPaypal

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << false

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << true

        // isOneOfPostPaymentDataRequestOneOf1Set

        << true

        // isValid                        // isSet

        << true                           << true;

    // check ::fromJson() works fine for VALID credit card object

    const QString validCard("{\"cardAvailability\":true,\"cardNumber\":\"1234-5678-9012-3456\"}"_L1);

    postRequest.fromJson(validCard);

    QTest::newRow("Set a valid CreditCard object via ::fromJson()")

        // postRequest                    // expectedJson

        << postRequest                    << validCard

        // expectedJsonValue

        << postRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << validCard                      << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << SchemasModelsOneOf::PostPaymentData_request_oneOf(validCard)

        // getOneOfPostPaymentData_request_oneOf_1

        << emptyPaypal

        // isOneOfPostPaymentDataRequestOneOfValid

        << true

        // isOneOfPostPaymentDataRequestOneOfSet

        << true

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << false

        // isOneOfPostPaymentDataRequestOneOf1Set

        << false

        // isValid                        // isSet

        << true                           << true;

    // check ::fromJsonValue() works fine for VALID credit card object

    const SchemasModelsOneOf::PostPaymentData_request_oneOf okCard(validCard);

    postRequest.fromJsonValue(okCard.asJsonValue());

    QTest::newRow("Set a valid CreditCard object via ::fromJsonValue()")

        // postRequest                    // expectedJson

        << postRequest                    << validCard

        // expectedJsonValue

        << postRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << validCard                      << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << okCard

        // getOneOfPostPaymentData_request_oneOf_1

        << emptyPaypal

        // isOneOfPostPaymentDataRequestOneOfValid

        << true

        // isOneOfPostPaymentDataRequestOneOfSet

        << true

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << false

        // isOneOfPostPaymentDataRequestOneOf1Set

        << false

        // isValid                        // isSet

        << true                           << true;

    // check ::fromJson() works fine for VALID paypal object

    // Note:  an empty credit card (emptyCreditCard) is not valid and not set,

    // because it has a required field.

    const QString validPaypal("{\"paypalAvailability\":true,\"paypalEmail\":\"user@example.com\"}"_L1);

    postRequest.fromJson(validPaypal);

    QTest::newRow("Set a valid Paypal object via ::fromJson()")

        // postRequest                    // expectedJson

        << postRequest                    << validPaypal

        // expectedJsonValue

        << postRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << validPaypal

        // getOneOfPostPaymentData_request_oneOf

        << emptyCreditCard

        // getOneOfPostPaymentData_request_oneOf_1

        << SchemasModelsOneOf::PostPaymentData_request_oneOf_1(validPaypal)

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << false

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << true

        // isOneOfPostPaymentDataRequestOneOf1Set

        << true

        // isValid                        // isSet

        << true                           << true;

    // check ::fromJsonValue() works fine for VALID paypal object

    const SchemasModelsOneOf::PostPaymentData_request_oneOf_1 okPaypal(validPaypal);

    postRequest.fromJsonValue(okPaypal.asJsonValue());

    QTest::newRow("Set a valid Paypal object via ::fromJsonValue()")

        // postRequest                    // expectedJson

        << postRequest                    << validPaypal

        // expectedJsonValue

        << postRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << validPaypal

        // getOneOfPostPaymentData_request_oneOf

        << emptyCreditCard

        // getOneOfPostPaymentData_request_oneOf_1

        << okPaypal

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << false

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << true

        // isOneOfPostPaymentDataRequestOneOf1Set

        << true

        // isValid                        // isSet

        << true                           << true;

    // invalid json! => the model is RESET to INITIAL state

    postRequest.fromJson("{invalid json}"_L1);

    QTest::newRow("Set an invalid json via ::fromJson()")

        // postRequest                    // expectedJson

        << postRequest                    << QString("{}"_L1)

        // expectedJsonValue

        << postRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << emptyCreditCard

        // getOneOfPostPaymentData_request_oneOf_1

        << emptyPaypal

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << false

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << false

        // isOneOfPostPaymentDataRequestOneOf1Set

        << false

        // isValid                        // isSet

        << false                          << false;

    // Test with non-object JSON (array) => the model is RESET to INITIAL state

    postRequest.fromJson("[]"_L1);

    QTest::newRow("Set an unexpected array [] via ::fromJson()")

        // postRequest                    // expectedJson

        << postRequest                    << QString("{}"_L1)

        // expectedJsonValue

        << postRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << emptyCreditCard

        // getOneOfPostPaymentData_request_oneOf_1

        << emptyPaypal

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << false

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << false

        // isOneOfPostPaymentDataRequestOneOf1Set

        << false

        // isValid                        // isSet

        << false                          << false;

    // Test with non-object JSON (string) => the model is RESET to INITIAL state

    postRequest.fromJson("\"just a string\""_L1);

    QTest::newRow("Set an unexpected string via ::fromJson()")

        // postRequest                    // expectedJson

        << postRequest                    << QString("{}"_L1)

        // expectedJsonValue

        << postRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << emptyCreditCard

        // getOneOfPostPaymentData_request_oneOf_1

        << emptyPaypal

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << false

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << false

        // isOneOfPostPaymentDataRequestOneOf1Set

        << false

        // isValid                        // isSet

        << false                          << false;

    // Missing Required Fields (CreditCard's 'cardNumber' is required)

    // CreditCard without required 'cardNumber' field - should not be valid

    SchemasModelsOneOf::PostPaymentData_request_oneOf invalidCard;

    invalidCard.setCardAvailability(true);

    postRequest.setOneOfPostPaymentData_request_oneOf(invalidCard);

    QTest::newRow("Set an invalid CreditCard via setter")

        // postRequest                    // expectedJson

        << postRequest                    << QString("{}"_L1)

        // expectedJsonValue

        << postRequest.asJsonValue()

        // oneOf0ExpectedJson                            // oneOf1ExpectedJson

        << QString("{\"cardAvailability\":true}"_L1)     << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << invalidCard

        // getOneOfPostPaymentData_request_oneOf_1

        << emptyPaypal

        // The status here reflects the status of the model that was set.

        // The model's field was set by setter, so invalidCard.isSet() == true

        // but invalidCard.isValid() == false, because required field is not set.

        // isOneOfPostPaymentDataRequestOneOfValid

        << invalidCard.isValid()

        // isOneOfPostPaymentDataRequestOneOfSet

        << invalidCard.isSet()

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << false

        // isOneOfPostPaymentDataRequestOneOf1Set

        << false

        // isValid                        // isSet

        << false                          << true;

    // Try to parse JSON missing required field for CreditCard.

    // cardNumber is required but missing => CreditCard is invalid.

    // Paypal has paypalAvailability (bool) but not cardAvailability,

    // so this doesn't match Paypal either since field name differs.

    postRequest.fromJson("{\"cardAvailability\":true}"_L1);

    QTest::newRow("Set an invalid CreditCard via ::fromJson()")

        // postRequest                    // expectedJson

        << postRequest                    << QString("{}"_L1)

        // expectedJsonValue

        << postRequest.asJsonValue()

        // oneOf0ExpectedJson                        // oneOf1ExpectedJson

        << QString("{\"cardAvailability\":true}"_L1) << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << SchemasModelsOneOf::PostPaymentData_request_oneOf("{\"cardAvailability\":true}"_L1)

        // getOneOfPostPaymentData_request_oneOf_1

        << emptyPaypal

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << true

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << false

        // isOneOfPostPaymentDataRequestOneOf1Set

        << false

        // isValid                        // isSet

        << false                          << true;

    // Partial/Incomplete JSON Objects

    // Only cardNumber for CreditCard (without cardAvailability),

    // should work since cardNumber is required and provided

    const QString cardOnly("{\"cardNumber\":\"9999-8888-7777-6666\"}"_L1);

    postRequest.fromJson(cardOnly);

    QTest::newRow("Set a valid non-full CreditCard via ::fromJson()")

        // postRequest                    // expectedJson

        << postRequest                    << cardOnly

        // expectedJsonValue

        << postRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << cardOnly                       << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << SchemasModelsOneOf::PostPaymentData_request_oneOf(cardOnly)

        // getOneOfPostPaymentData_request_oneOf_1

        << emptyPaypal

        // isOneOfPostPaymentDataRequestOneOfValid

        << true

        // isOneOfPostPaymentDataRequestOneOfSet

        << true

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << false

        // isOneOfPostPaymentDataRequestOneOf1Set

        << false

        // isValid                        // isSet

        << true                           << true;

    // Only paypalEmail for Paypal (without paypalAvailability),

    // should work since Paypal has no required fields

    const QString emailOnly("{\"paypalEmail\":\"test@test.com\"}"_L1);

    postRequest.fromJson(emailOnly);

    QTest::newRow("Set a valid non-full Paypal via ::fromJson()")

        // postRequest                    // expectedJson

        << postRequest                    << emailOnly

        // expectedJsonValue

        << postRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << emailOnly

        // getOneOfPostPaymentData_request_oneOf

        << emptyCreditCard

        // getOneOfPostPaymentData_request_oneOf_1

        << SchemasModelsOneOf::PostPaymentData_request_oneOf_1(emailOnly)

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << false

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << true

        // isOneOfPostPaymentDataRequestOneOf1Set

        << true

        // isValid                        // isSet

        << true                           << true;

    // Extra/Unknown Fields in JSON

    // JSON with fields not in schema - should parse known fields and ignore unknown

    postRequest.fromJson("{\"cardNumber\":\"4444-3333\",\"cardAvailability\":false,"

                         "\"unknown\":\"field\",\"extra\":123}"_L1);

    QString expected("{\"cardAvailability\":false,\"cardNumber\":\"4444-3333\"}"_L1);

    QTest::newRow("Extra/Unknown Fields in CreditCard JSON via ::fromJson()")

        // postRequest                    // expectedJson

        << postRequest                    << expected

        // expectedJsonValue

        << postRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << expected                       << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << SchemasModelsOneOf::PostPaymentData_request_oneOf(expected)

        // getOneOfPostPaymentData_request_oneOf_1

        << emptyPaypal

        // isOneOfPostPaymentDataRequestOneOfValid

        << true

        // isOneOfPostPaymentDataRequestOneOfSet

        << true

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << false

        // isOneOfPostPaymentDataRequestOneOf1Set

        << false

        // isValid                        // isSet

        << true                           << true;

    // Extra/Unknown Fields in Paypal JSON

    postRequest.fromJson("{\"paypalEmail\":\"a@b.com\",\"paypalAvailability\""

                         ":true,\"foo\":\"bar\"}"_L1);

    expected = QString("{\"paypalAvailability\":true,\"paypalEmail\":\"a@b.com\"}"_L1);

    QTest::newRow("Extra/Unknown Fields in Paypal JSON via ::fromJson()")

        // postRequest                    // expectedJson

        << postRequest                    << expected

        // expectedJsonValue

        << postRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << expected

        // getOneOfPostPaymentData_request_oneOf

        << emptyCreditCard

        // getOneOfPostPaymentData_request_oneOf_1

        << SchemasModelsOneOf::PostPaymentData_request_oneOf_1(expected)

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << false

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << true

        // isOneOfPostPaymentDataRequestOneOf1Set

        << true

        // isValid                        // isSet

        << true                           << true;

    // Empty String in CreditCard cardNumber field

    // cardNumber is required and present (even though empty string), so it's valid

    expected = QString("{\"cardNumber\":\"\"}"_L1);

    postRequest.fromJson(expected);

    QTest::newRow("An empty String in CreditCard cardNumber field via ::fromJson()")

        // postRequest                    // expectedJson

        << postRequest                    << expected

        // expectedJsonValue

        << postRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << expected                       << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << SchemasModelsOneOf::PostPaymentData_request_oneOf(expected)

        // getOneOfPostPaymentData_request_oneOf_1

        << emptyPaypal

        // isOneOfPostPaymentDataRequestOneOfValid

        << true

        // isOneOfPostPaymentDataRequestOneOfSet

        << true

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << false

        // isOneOfPostPaymentDataRequestOneOf1Set

        << false

        // isValid                        // isSet

        << true                           << true;

    // Invalid Field Types for CreditCard. Wrong type for cardNumber (integer instead of string)

    // The CreditCard is set, but invalid, because the required field is ommited due to invalid

    // data. The entire model returns {}, the getter returns the data was valid on setting:

    // {\"cardAvailability\":true}

    expected = QString("{\"cardNumber\":12345,\"cardAvailability\":true}"_L1);

    postRequest.fromJson(expected);

    QTest::newRow("Invalid field 'cardNumber=12345' in CreditCard via ::fromJson()")

        // postRequest                    // expectedJson

        << postRequest                    << QString("{}"_L1)

        // expectedJsonValue

        << postRequest.asJsonValue()

        // oneOf0ExpectedJson                          // oneOf1ExpectedJson

        << QString("{\"cardAvailability\":true}"_L1)   << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << SchemasModelsOneOf::PostPaymentData_request_oneOf(expected)

        // getOneOfPostPaymentData_request_oneOf_1

        << emptyPaypal

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << true

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << false

        // isOneOfPostPaymentDataRequestOneOf1Set

        << false

        // isValid                        // isSet

        << false                          << true;

    // Invalid Field Types for CreditCard. Wrong type for cardAvailability (string instead of bool)

    expected = QString("{\"cardNumber\":\"5555\",\"cardAvailability\":\"yes\"}"_L1);

    postRequest.fromJson(expected);

    QTest::newRow("Invalid field 'cardAvailability=yes' in CreditCard via ::fromJson()")

        // postRequest                    // expectedJson

        << postRequest                    << QString("{\"cardNumber\":\"5555\"}"_L1)

        // expectedJsonValue

        << postRequest.asJsonValue()

        // oneOf0ExpectedJson                      // oneOf1ExpectedJson

        << QString("{\"cardNumber\":\"5555\"}"_L1) << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << SchemasModelsOneOf::PostPaymentData_request_oneOf(expected)

        // getOneOfPostPaymentData_request_oneOf_1

        << emptyPaypal

        // isOneOfPostPaymentDataRequestOneOfValid

        << true

        // isOneOfPostPaymentDataRequestOneOfSet

        << true

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << false

        // isOneOfPostPaymentDataRequestOneOf1Set

        << false

        // isValid                        // isSet

        << true                           << true;

    // Invalid Field Types for Paypal. Wrong type for paypalAvailability (integer instead of bool)

    // Note: paypalAvailability is optional, so wrong type is just omitted

    expected = QString("{\"paypalEmail\":\"x@y.com\",\"paypalAvailability\":1}"_L1);

    postRequest.fromJson(expected);

    QTest::newRow("Invalid field 'paypalAvailability=1' in Paypal via ::fromJson()")

        // postRequest                    // expectedJson

        << postRequest                    << QString("{\"paypalEmail\":\"x@y.com\"}"_L1)

        // expectedJsonValue

        << postRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{\"paypalEmail\":\"x@y.com\"}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << emptyCreditCard

        // getOneOfPostPaymentData_request_oneOf_1

        << SchemasModelsOneOf::PostPaymentData_request_oneOf_1(expected)

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << false

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << true

        // isOneOfPostPaymentDataRequestOneOf1Set

        << true

        // isValid                        // isSet

        << true                           << true;

    // Invalid Field Types for Paypal. Wrong type for paypalEmail (bool instead of string)

    // Note: paypalEmail is optional, so wrong type is just omitted

    expected = QString("{\"paypalEmail\":true,\"paypalAvailability\":false}"_L1);

    postRequest.fromJson(expected);

    QTest::newRow("Invalid field 'paypalEmail=true' in Paypal via ::fromJson()")

        // postRequest                    // expectedJson

        << postRequest                    << QString("{\"paypalAvailability\":false}"_L1)

        // expectedJsonValue

        << postRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{\"paypalAvailability\":false}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << emptyCreditCard

        // getOneOfPostPaymentData_request_oneOf_1

        << SchemasModelsOneOf::PostPaymentData_request_oneOf_1(expected)

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << false

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << true

        // isOneOfPostPaymentDataRequestOneOf1Set

        << true

        // isValid                        // isSet

        << true                           << true;

    // All fields have wrong types - both oneOfs fail to parse valid data

    expected = QString("{\"cardNumber\":true,\"cardAvailability\":\"yes\"}"_L1);

    postRequest.fromJson(expected);

    QTest::newRow("All invalid fields in CreditCard via ::fromJson()")

        // postRequest                    // expectedJson

        << postRequest                    << QString("{}"_L1)

        // expectedJsonValue

        << postRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << emptyCreditCard

        // getOneOfPostPaymentData_request_oneOf_1

        << emptyPaypal

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << false

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << false

        // isOneOfPostPaymentDataRequestOneOf1Set

        << false

        // isValid                        // isSet

        << false                          << false;

    // CreditCard with only required field set via setter

    SchemasModelsOneOf::PostPaymentData_request_oneOf cardOnly2;

    cardOnly2.setCardNumber("0000-1111-2222-3333"_L1);

    postRequest.setOneOfPostPaymentData_request_oneOf(cardOnly2);

    QTest::newRow("Set CreditCard with only cardNumber via setter")

        // postRequest                    // expectedJson

        << postRequest                    << cardOnly2.asJson()

        // expectedJsonValue

        << cardOnly2.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << cardOnly2.asJson()             << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << cardOnly2

        // getOneOfPostPaymentData_request_oneOf_1

        << emptyPaypal

        // isOneOfPostPaymentDataRequestOneOfValid

        << true

        // isOneOfPostPaymentDataRequestOneOfSet

        << true

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << false

        // isOneOfPostPaymentDataRequestOneOf1Set

        << false

        // isValid                        // isSet

        << true                           << true;

    // Paypal with only paypalAvailability set via setter

    SchemasModelsOneOf::PostPaymentData_request_oneOf_1 availOnly;

    availOnly.setPaypalAvailability(false);

    postRequest.setOneOfPostPaymentData_request_oneOf_1(availOnly);

    QTest::newRow("Set Paypal with only paypalAvailability via setter")

        // postRequest                    // expectedJson

        << postRequest                    << availOnly.asJson()

        // expectedJsonValue

        << availOnly.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << availOnly.asJson()

        // getOneOfPostPaymentData_request_oneOf

        << emptyCreditCard

        // getOneOfPostPaymentData_request_oneOf_1

        << availOnly

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << false

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << true

        // isOneOfPostPaymentDataRequestOneOf1Set

        << true

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue with valid CreditCard data

    postRequest.fromJsonValue(creditCard.asJsonValue());

    QTest::newRow("Set a valid CreditCard via ::fromJsonValue(creditCard.asJsonValue())")

        // postRequest                    // expectedJson

        << postRequest                    << creditCard.asJson()

        // expectedJsonValue

        << postRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << creditCard.asJson()            << QString("{}"_L1)

        // getOneOfPostPaymentData_request_oneOf

        << creditCard

        // getOneOfPostPaymentData_request_oneOf_1

        << emptyPaypal

        // isOneOfPostPaymentDataRequestOneOfValid

        << true

        // isOneOfPostPaymentDataRequestOneOfSet

        << true

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << false

        // isOneOfPostPaymentDataRequestOneOf1Set

        << false

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue with valid Paypal data

    postRequest.fromJsonValue(paypal.asJsonValue());

    QTest::newRow("Set a valid Paypal via ::fromJsonValue(paypal.asJsonValue())")

        // postRequest                    // expectedJson

        << postRequest                    << paypal.asJson()

        // expectedJsonValue

        << postRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << paypal.asJson()

        // getOneOfPostPaymentData_request_oneOf

        << emptyCreditCard

        // getOneOfPostPaymentData_request_oneOf_1

        << paypal

        // isOneOfPostPaymentDataRequestOneOfValid

        << false

        // isOneOfPostPaymentDataRequestOneOfSet

        << false

        // isOneOfPostPaymentDataRequestOneOf1Valid

        << true

        // isOneOfPostPaymentDataRequestOneOf1Set

        << true

        // isValid                        // isSet

        << true                           << true;

void OneOfTest::testInlineSchemasJsonConversionMethods()

    QFETCH(SchemasModelsOneOf::PostPaymentData_request, postRequest);

    QFETCH(QString, expectedJson);

    QFETCH(QJsonValue, expectedJsonValue);

    QFETCH(QString, oneOf0ExpectedJson);

    QFETCH(QString, oneOf1ExpectedJson);

    QFETCH(SchemasModelsOneOf::PostPaymentData_request_oneOf,

           getOneOfPostPaymentData_request_oneOf);

    QFETCH(SchemasModelsOneOf::PostPaymentData_request_oneOf_1,

           getOneOfPostPaymentData_request_oneOf_1);

    QFETCH(bool, isOneOfPostPaymentDataRequestOneOfValid);

    QFETCH(bool, isOneOfPostPaymentDataRequestOneOfSet);

    QFETCH(bool, isOneOfPostPaymentDataRequestOneOf1Valid);

    QFETCH(bool, isOneOfPostPaymentDataRequestOneOf1Set);

    QFETCH(bool, isValid);

    QFETCH(bool, isSet);

    QCOMPARE(postRequest.asJson(), expectedJson);

    QCOMPARE(postRequest.asJsonValue(), expectedJsonValue);

    QCOMPARE(postRequest.getOneOfPostPaymentData_request_oneOf().asJson(),

             oneOf0ExpectedJson);

    QCOMPARE(postRequest.isOneOfPostPaymentDataRequestOneOfValid(),

             isOneOfPostPaymentDataRequestOneOfValid);

    QCOMPARE(postRequest.isOneOfPostPaymentDataRequestOneOfSet(),

             isOneOfPostPaymentDataRequestOneOfSet);

    QCOMPARE(postRequest.getOneOfPostPaymentData_request_oneOf_1().asJson(),

             oneOf1ExpectedJson);

    QCOMPARE(postRequest.isOneOfPostPaymentDataRequestOneOf1Valid(),

             isOneOfPostPaymentDataRequestOneOf1Valid);

    QCOMPARE(postRequest.isOneOfPostPaymentDataRequestOneOf1Set(),

             isOneOfPostPaymentDataRequestOneOf1Set);

    QCOMPARE(postRequest.getOneOfPostPaymentData_request_oneOf(),

             getOneOfPostPaymentData_request_oneOf);

    QCOMPARE(postRequest.getOneOfPostPaymentData_request_oneOf_1(),

             getOneOfPostPaymentData_request_oneOf_1);

    QCOMPARE(postRequest.isValid(), isValid);

    QCOMPARE(postRequest.isSet(), isSet);

void OneOfTest::testInlineSchemasPatch_data()

    QTest::addColumn<SchemasModelsOneOf::PatchPaymentData_request>("patchPaymentRequest");

    QTest::addColumn<QString>("stringValue");

    QTest::addColumn<bool>("boolValue");

    QTest::addColumn<double>("doubleValue");

    QTest::addColumn<OneOfTest::BankApiPatchMode>("mode");

    QTest::addColumn<QString>("expectedJson");

    // Empty patchPaymentRequest

    QTest::newRow("empty PatchPaymentData_request")

        << SchemasModelsOneOf::PatchPaymentData_request{}

        << QString()

        << false

        << 0.0

        << OneOfTest::BankApiPatchMode::UsePatchPaymentRequest

        << QString("{}"_L1);

    // Test patchPaymentData with string value

    QTest::newRow("string value")

        << SchemasModelsOneOf::PatchPaymentData_request{}

        << QString("test-string-value"_L1)

        << false

        << 0.0

        << OneOfTest::BankApiPatchMode::UseString

        << QString("\"test-string-value\""_L1);

    // Test patchPaymentData with bool value

    QTest::newRow("bool value true")

        << SchemasModelsOneOf::PatchPaymentData_request{}

        << QString()

        << true

        << 0.0

        << OneOfTest::BankApiPatchMode::UseBool

        << QString("true"_L1);

    QTest::newRow("bool value false")

        << SchemasModelsOneOf::PatchPaymentData_request{}

        << QString()

        << false

        << 0.0

        << OneOfTest::BankApiPatchMode::UseBool

        << QString("false"_L1);

    // Test patchPaymentData with double value

    QTest::newRow("double value")

        << SchemasModelsOneOf::PatchPaymentData_request{}

        << QString()

        << false

        << 42.5

        << OneOfTest::BankApiPatchMode::UseDouble

        << QString("42.5"_L1);

    // Test PatchPaymentData_request with string set

    SchemasModelsOneOf::PatchPaymentData_request patchRequest;

    patchRequest.setOneOfQString("request-string"_L1);

    QTest::newRow("PatchPaymentData_request with string")

        << patchRequest

        << QString()

        << false

        << 0.0

        << OneOfTest::BankApiPatchMode::UsePatchPaymentRequest

        << QString("\"request-string\""_L1);

    // Test PatchPaymentData_request with bool set

    patchRequest.setOneOfBool(true);

    QTest::newRow("PatchPaymentData_request with bool")

        << patchRequest

        << QString()

        << false

        << 0.0

        << OneOfTest::BankApiPatchMode::UsePatchPaymentRequest

        << QString("true"_L1);

    // Test PatchPaymentData_request with double set

    patchRequest.setOneOfDouble(99.99);

    QTest::newRow("PatchPaymentData_request with double")

        << patchRequest

        << QString()

        << false

        << 0.0

        << OneOfTest::BankApiPatchMode::UsePatchPaymentRequest

        << QString("99.99"_L1);

void OneOfTest::testInlineSchemasPatch()

    QFETCH(SchemasModelsOneOf::PatchPaymentData_request, patchPaymentRequest);

    QFETCH(QString, stringValue);

    QFETCH(bool, boolValue);

    QFETCH(double, doubleValue);

    QFETCH(OneOfTest::BankApiPatchMode, mode);

    QFETCH(QString, expectedJson);

    bool done = true;

    SchemasModelsOneOf::BankApi bankApi;

    LoggingNetworkAccessManager logging(&bankApi);

    QRestAccessManager restManager(&logging, &bankApi);

    bankApi.setRestAccessManager(&restManager);

    switch (mode) {

    case OneOfTest::BankApiPatchMode::UsePatchPaymentRequest:

        bankApi.patchPaymentData(patchPaymentRequest, this, [&](const QRestReply &reply) {

            done = reply.isSuccess();

});

    } break;

    case OneOfTest::BankApiPatchMode::UseString:

        bankApi.patchPaymentData(stringValue, this, [&](const QRestReply &reply) {

            done = reply.isSuccess();

});

    } break;

    case OneOfTest::BankApiPatchMode::UseBool:

        bankApi.patchPaymentData(boolValue, this, [&](const QRestReply &reply) {

            done = reply.isSuccess();

});

    } break;

    case OneOfTest::BankApiPatchMode::UseDouble:

        bankApi.patchPaymentData(doubleValue, this, [&](const QRestReply &reply) {

            done = reply.isSuccess();

});

    } break;

    QCOMPARE(logging.m_content, expectedJson);

    QTRY_COMPARE_EQ(done, false);

void OneOfTest::testInlineSchemasPost_data()

    QTest::addColumn<SchemasModelsOneOf::PostPaymentData_request>("postPaymentRequest");

    QTest::addColumn<SchemasModelsOneOf::PostPaymentData_request_oneOf>("creditCard");

    QTest::addColumn<SchemasModelsOneOf::PostPaymentData_request_oneOf_1>("paypal");

    QTest::addColumn<OneOfTest::BankApiPostMode>("mode");

    QTest::addColumn<QString>("expectedJson");

    // Empty postPaymentRequest

    QTest::newRow("empty PostPaymentData_request")

        << SchemasModelsOneOf::PostPaymentData_request{}

        << SchemasModelsOneOf::PostPaymentData_request_oneOf{}

        << SchemasModelsOneOf::PostPaymentData_request_oneOf_1{}

        << OneOfTest::BankApiPostMode::UsePostPaymentRequest

        << QString("{}"_L1);

    // Test Credit Card payment with required field

    SchemasModelsOneOf::PostPaymentData_request_oneOf creditCard;

    creditCard.setCardNumber("1234-5678-9012-3456"_L1);

    creditCard.setCardAvailability(true);

    QTest::newRow("credit card with required field")

        << SchemasModelsOneOf::PostPaymentData_request{}

        << creditCard

        << SchemasModelsOneOf::PostPaymentData_request_oneOf_1{}

        << OneOfTest::BankApiPostMode::UseCreditCard

        << QString("{\"cardAvailability\":true,\"cardNumber\":\"1234-5678-9012-3456\"}"_L1);

    // Test PayPal payment

    SchemasModelsOneOf::PostPaymentData_request_oneOf_1 paypal;

    paypal.setPaypalEmail("user@example.com"_L1);

    paypal.setPaypalAvailability(true);

    QTest::newRow("paypal payment")

        << SchemasModelsOneOf::PostPaymentData_request{}

        << SchemasModelsOneOf::PostPaymentData_request_oneOf{}

        << paypal

        << OneOfTest::BankApiPostMode::UsePaypal

        << QString("{\"paypalAvailability\":true,\"paypalEmail\":\"user@example.com\"}"_L1);

    // Test PostPaymentData_request with credit card set

    SchemasModelsOneOf::PostPaymentData_request postRequest;

    postRequest.setOneOfPostPaymentData_request_oneOf(creditCard);

    QTest::newRow("PostPaymentData_request with credit card")

        << postRequest

        << SchemasModelsOneOf::PostPaymentData_request_oneOf{}

        << SchemasModelsOneOf::PostPaymentData_request_oneOf_1{}

        << OneOfTest::BankApiPostMode::UsePostPaymentRequest

        << QString("{\"cardAvailability\":true,\"cardNumber\":\"1234-5678-9012-3456\"}"_L1);

    // Test PostPaymentData_request with PayPal set

    postRequest.setOneOfPostPaymentData_request_oneOf_1(paypal);

    QTest::newRow("PostPaymentData_request with paypal")

        << postRequest

        << SchemasModelsOneOf::PostPaymentData_request_oneOf{}

        << SchemasModelsOneOf::PostPaymentData_request_oneOf_1{}

        << OneOfTest::BankApiPostMode::UsePostPaymentRequest

        << QString("{\"paypalAvailability\":true,\"paypalEmail\":\"user@example.com\"}"_L1);

    // Test credit card without required field (cardNumber is required)

    SchemasModelsOneOf::PostPaymentData_request_oneOf invalidCreditCard;

    invalidCreditCard.setCardAvailability(true);

    QTest::newRow("invalid credit card missing required field")

        << SchemasModelsOneOf::PostPaymentData_request{}

        << invalidCreditCard

        << SchemasModelsOneOf::PostPaymentData_request_oneOf_1{}

        << OneOfTest::BankApiPostMode::UseCreditCard

        << QString("{}"_L1);

    // Test PayPal with only email (paypalAvailability is optional)

    SchemasModelsOneOf::PostPaymentData_request_oneOf_1 partialPaypal;

    partialPaypal.setPaypalEmail("partial@example.com"_L1);

    QTest::newRow("paypal with only email")

        << SchemasModelsOneOf::PostPaymentData_request{}

        << SchemasModelsOneOf::PostPaymentData_request_oneOf{}

        << partialPaypal

        << OneOfTest::BankApiPostMode::UsePaypal

        << QString("{\"paypalEmail\":\"partial@example.com\"}"_L1);

void OneOfTest::testInlineSchemasPost()

    QFETCH(SchemasModelsOneOf::PostPaymentData_request, postPaymentRequest);

    QFETCH(SchemasModelsOneOf::PostPaymentData_request_oneOf, creditCard);

    QFETCH(SchemasModelsOneOf::PostPaymentData_request_oneOf_1, paypal);

    QFETCH(OneOfTest::BankApiPostMode, mode);

    QFETCH(QString, expectedJson);

    bool done = true;

    SchemasModelsOneOf::BankApi bankApi;

    LoggingNetworkAccessManager logging(&bankApi);

    QRestAccessManager restManager(&logging, &bankApi);

    bankApi.setRestAccessManager(&restManager);

    switch (mode) {

    case OneOfTest::BankApiPostMode::UsePostPaymentRequest:

        bankApi.postPaymentData(postPaymentRequest, this, [&](const QRestReply &reply) {

            done = reply.isSuccess();

});

    } break;

    case OneOfTest::BankApiPostMode::UseCreditCard:

        bankApi.postPaymentData(creditCard, this, [&](const QRestReply &reply) {

            done = reply.isSuccess();

});

    } break;

    case OneOfTest::BankApiPostMode::UsePaypal:

        bankApi.postPaymentData(paypal, this, [&](const QRestReply &reply) {

            done = reply.isSuccess();

});

    } break;

    QCOMPARE(logging.m_content, expectedJson);

    QTRY_COMPARE_EQ(done, false);

void OneOfTest::testOneOfPrimitiveJsonConversionMethods_data()

    QTest::addColumn<SchemasModelsOneOf::PatchPaymentData_request>("patchRequest");

    QTest::addColumn<QString>("expectedJson");

    QTest::addColumn<QJsonValue>("expectedJsonValue");

    QTest::addColumn<QString>("getOneOfQString");

    QTest::addColumn<bool>("getOneOfBool");

    QTest::addColumn<double>("getOneOfDouble");

    QTest::addColumn<bool>("isOneOfQStringValid");

    QTest::addColumn<bool>("isOneOfQStringSet");

    QTest::addColumn<bool>("isOneOfBoolValid");

    QTest::addColumn<bool>("isOneOfBoolSet");

    QTest::addColumn<bool>("isOneOfDoubleValid");

    QTest::addColumn<bool>("isOneOfDoubleSet");

    QTest::addColumn<bool>("isValid");

    QTest::addColumn<bool>("isSet");

    // PatchPaymentData_request has three primitive oneOf alternatives:

    // oneOf0: string

    // oneOf1: boolean

    // oneOf2: number (double)

    // All primitives have no "required fields" concept, so they are always "valid".

    SchemasModelsOneOf::PatchPaymentData_request patchRequest;

    QTest::newRow("Empty PatchPaymentData_request object")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // getOneOfQString                // getOneOfBool

        << QString()                      << false

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Set a string value via setter

    const QString hello("hello-world"_L1);

    patchRequest.setOneOfQString(hello);

    QTest::newRow("Set a valid string via setter")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("\"hello-world\""_L1)

        // expectedJsonValue

        << QJsonValue(hello)

        // getOneOfQString                // getOneOfBool

        << hello                          << false

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << true                           << true

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set a bool value via setter (overrides string)

    patchRequest.setOneOfBool(true);

    QTest::newRow("Set a valid bool 'true' via setter")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("true"_L1)

        // expectedJsonValue

        << QJsonValue(true)

        // getOneOfQString                // getOneOfBool

        << QString()                      << true

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << true                           << true

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set a bool 'false' value via setter

    patchRequest.setOneOfBool(false);

    QTest::newRow("Set a valid bool 'false' via setter")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("false"_L1)

        // expectedJsonValue

        << QJsonValue(false)

        // getOneOfQString                // getOneOfBool

        << QString()                      << false

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << true                           << true

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set a double value via setter (overrides bool)

    patchRequest.setOneOfDouble(42.5);

    QTest::newRow("Set a valid double '42.5' via setter")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("42.5"_L1)

        // expectedJsonValue

        << QJsonValue(42.5)

        // getOneOfQString                // getOneOfBool

        << QString()                      << false

        // getOneOfDouble

        << 42.5

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // Set a negative double value via setter

    patchRequest.setOneOfDouble(-99.99);

    QTest::newRow("Set a valid double '-99.99' via setter")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("-99.99"_L1)

        // expectedJsonValue

        << QJsonValue(-99.99)

        // getOneOfQString                // getOneOfBool

        << QString()                      << false

        // getOneOfDouble

        << -99.99

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // Set a zero double value via setter

    patchRequest.setOneOfDouble(0.0);

    QTest::newRow("Set a valid double '0.0' via setter")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("0"_L1)

        // expectedJsonValue

        << QJsonValue(0.0)

        // getOneOfQString                // getOneOfBool

        << QString()                      << false

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // Set an empty string via setter

    patchRequest.setOneOfQString("");

    QTest::newRow("Set an empty string via setter")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("\"\""_L1)

        // expectedJsonValue

        << QJsonValue(""_L1)

        // getOneOfQString                // getOneOfBool

        << QString(""_L1)                 << false

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << true                           << true

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson with a string value

    patchRequest.fromJson("\"payment-token-abc\""_L1);

    QTest::newRow("Set a valid string via ::fromJson()")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("\"payment-token-abc\""_L1)

        // expectedJsonValue

        << QJsonValue("payment-token-abc"_L1)

        // getOneOfQString                // getOneOfBool

        << QString("payment-token-abc"_L1) << false

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << true                           << true

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson with a bool 'true' value

    patchRequest.fromJson("true"_L1);

    QTest::newRow("Set a valid bool 'true' via ::fromJson()")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("true"_L1)

        // expectedJsonValue

        << QJsonValue(true)

        // getOneOfQString                // getOneOfBool

        << QString()                      << true

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << true                           << true

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson with a bool 'false' value

    patchRequest.fromJson("false"_L1);

    QTest::newRow("Set a valid bool 'false' via ::fromJson()")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("false"_L1)

        // expectedJsonValue

        << QJsonValue(false)

        // getOneOfQString                // getOneOfBool

        << QString()                      << false

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << true                           << true

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson with a double value

    patchRequest.fromJson("3.14159"_L1);

    QTest::newRow("Set a valid double '3.14159' via ::fromJson()")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("3.14159"_L1)

        // expectedJsonValue

        << QJsonValue(3.14159)

        // getOneOfQString                // getOneOfBool

        << QString()                      << false

        // getOneOfDouble

        << 3.14159

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // fromJson with a negative double value

    patchRequest.fromJson("-100.5"_L1);

    QTest::newRow("Set a valid double '-100.5' via ::fromJson()")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("-100.5"_L1)

        // expectedJsonValue

        << QJsonValue(-100.5)

        // getOneOfQString                // getOneOfBool

        << QString()                      << false

        // getOneOfDouble

        << -100.5

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // fromJson with an integer value (should match double/number)

    patchRequest.fromJson("42"_L1);

    QTest::newRow("Set an integer '42' via ::fromJson() (matches double)")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("42"_L1)

        // expectedJsonValue

        << QJsonValue(42.0)

        // getOneOfQString                // getOneOfBool

        << QString()                      << false

        // getOneOfDouble

        << 42.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue with a string value

    patchRequest.fromJsonValue(QJsonValue("json-value-string"_L1));

    QTest::newRow("Set a valid string via ::fromJsonValue()")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("\"json-value-string\""_L1)

        // expectedJsonValue

        << QJsonValue("json-value-string"_L1)

        // getOneOfQString                // getOneOfBool

        << QString("json-value-string"_L1) << false

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << true                           << true

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue with a bool value

    patchRequest.fromJsonValue(QJsonValue(true));

    QTest::newRow("Set a valid bool 'true' via ::fromJsonValue()")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("true"_L1)

        // expectedJsonValue

        << QJsonValue(true)

        // getOneOfQString                // getOneOfBool

        << QString()                      << true

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << true                           << true

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue with a double value

    patchRequest.fromJsonValue(QJsonValue(99.99));

    QTest::newRow("Set a valid double '99.99' via ::fromJsonValue()")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("99.99"_L1)

        // expectedJsonValue

        << QJsonValue(99.99)

        // getOneOfQString                // getOneOfBool

        << QString()                      << false

        // getOneOfDouble

        << 99.99

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // invalid json! => the model is RESET to INITIAL state

    patchRequest.fromJson("{invalid json}"_L1);

    QTest::newRow("Set an invalid json via ::fromJson()")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // getOneOfQString                // getOneOfBool

        << QString()                      << false

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Test with non-primitive JSON (object) => doesn't match any primitive type

    patchRequest.fromJson("{\"key\":\"value\"}"_L1);

    QTest::newRow("Set an unexpected object via ::fromJson()")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // getOneOfQString                // getOneOfBool

        << QString()                      << false

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Test with non-primitive JSON (array) => doesn't match any primitive type

    patchRequest.fromJson("[1, 2, 3]"_L1);

    QTest::newRow("PatchPaymentData_request: set an unexpected array via ::fromJson()")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // getOneOfQString                // getOneOfBool

        << QString()                      << false

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Test with null JSON value => doesn't match string/bool/double

    patchRequest.fromJson("null"_L1);

    QTest::newRow("Set a null value via ::fromJson()")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // getOneOfQString                // getOneOfBool

        << QString()                      << false

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // fromJsonValue with null QJsonValue => doesn't match primitives

    patchRequest.fromJsonValue(QJsonValue());

    QTest::newRow("Set a null QJsonValue via ::fromJsonValue()")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // getOneOfQString                // getOneOfBool

        << QString()                      << false

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // fromJsonValue with QJsonObject => doesn't match primitives

    patchRequest.fromJsonValue(QJsonValue(QJsonObject()));

    QTest::newRow("Set an empty QJsonObject via ::fromJsonValue()")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // getOneOfQString                // getOneOfBool

        << QString()                      << false

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // fromJson with an empty string JSON => should match string (oneOf0)

    patchRequest.fromJson("\"\""_L1);

    QTest::newRow("Set an empty string via ::fromJson()")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("\"\""_L1)

        // expectedJsonValue

        << QJsonValue(""_L1)

        // getOneOfQString                // getOneOfBool

        << QString(""_L1)                 << false

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << true                           << true

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson with a very large double

    patchRequest.fromJson("1.7976931348623157e+308"_L1);

    QTest::newRow("Set a very large double via ::fromJson()")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("1.7976931348623157e+308"_L1)

        // expectedJsonValue

        << QJsonValue(1.7976931348623157e+308)

        // getOneOfQString                // getOneOfBool

        << QString()                      << false

        // getOneOfDouble

        << 1.7976931348623157e+308

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // fromJson with a string that looks like a number (but is quoted => string)

    patchRequest.fromJson("\"42.5\""_L1);

    QTest::newRow("Set a string '42.5' (quoted) via ::fromJson()")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("\"42.5\""_L1)

        // expectedJsonValue

        << QJsonValue("42.5"_L1)

        // getOneOfQString                // getOneOfBool

        << QString("42.5"_L1)             << false

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << true                           << true

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson with a string that looks like a bool (but is quoted => string)

    patchRequest.fromJson("\"true\""_L1);

    QTest::newRow("Set a string 'true' (quoted) via ::fromJson()")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("\"true\""_L1)

        // expectedJsonValue

        << QJsonValue("true"_L1)

        // getOneOfQString                // getOneOfBool

        << QString("true"_L1)             << false

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << true                           << true

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson with zero (integer form) => matches double

    patchRequest.fromJson("0"_L1);

    QTest::newRow("Set zero '0' via ::fromJson() (matches double)")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("0"_L1)

        // expectedJsonValue

        << QJsonValue(0.0)

        // getOneOfQString                // getOneOfBool

        << QString()                      << false

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // Set string with special characters via setter

    patchRequest.setOneOfQString("hello \"world\" \n\ttab"_L1);

    QTest::newRow("Set a string with special characters via setter")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("\"hello \\\"world\\\" \\n\\ttab\""_L1)

        // expectedJsonValue

        << QJsonValue("hello \"world\" \n\ttab"_L1)

        // getOneOfQString                // getOneOfBool

        << QString("hello \"world\" \n\ttab"_L1) << false

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << true                           << true

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set double via setter then override with string via setter

    patchRequest.setOneOfDouble(123.456);

    patchRequest.setOneOfQString("override"_L1);

    QTest::newRow("Override double with string via setter")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("\"override\""_L1)

        // expectedJsonValue

        << QJsonValue("override"_L1)

        // getOneOfQString                // getOneOfBool

        << QString("override"_L1)         << false

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << true                           << true

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set string via setter then override with bool via setter

    patchRequest.setOneOfQString("will be overridden"_L1);

    patchRequest.setOneOfBool(false);

    QTest::newRow("Override string with bool 'false' via setter")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("false"_L1)

        // expectedJsonValue

        << QJsonValue(false)

        // getOneOfQString                // getOneOfBool

        << QString()                      << false

        // getOneOfDouble

        << 0.0

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << true                           << true

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set bool via setter then override with double via setter

    patchRequest.setOneOfBool(true);

    patchRequest.setOneOfDouble(0.001);

    QTest::newRow("Override bool with double '0.001' via setter")

        // patchRequest                   // expectedJson

        << patchRequest                   << QString("0.001"_L1)

        // expectedJsonValue

        << QJsonValue(0.001)

        // getOneOfQString                // getOneOfBool

        << QString()                      << false

        // getOneOfDouble

        << 0.001

        // isOneOfQStringValid            // isOneOfQStringSet

        << false                          << false

        // isOneOfBoolValid               // isOneOfBoolSet

        << false                          << false

        // isOneOfDoubleValid             // isOneOfDoubleSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

void OneOfTest::testOneOfPrimitiveJsonConversionMethods()

    QFETCH(SchemasModelsOneOf::PatchPaymentData_request, patchRequest);

    QFETCH(QString, expectedJson);

    QFETCH(QJsonValue, expectedJsonValue);

    QFETCH(QString, getOneOfQString);

    QFETCH(bool, getOneOfBool);

    QFETCH(double, getOneOfDouble);

    QFETCH(bool, isOneOfQStringValid);

    QFETCH(bool, isOneOfQStringSet);

    QFETCH(bool, isOneOfBoolValid);

    QFETCH(bool, isOneOfBoolSet);

    QFETCH(bool, isOneOfDoubleValid);

    QFETCH(bool, isOneOfDoubleSet);

    QFETCH(bool, isValid);

    QFETCH(bool, isSet);

    QCOMPARE(patchRequest.asJson(), expectedJson);

    QCOMPARE(patchRequest.asJsonValue(), expectedJsonValue);

    QCOMPARE(patchRequest.getOneOfQString(), getOneOfQString);

    QCOMPARE(patchRequest.isOneOfQStringValid(), isOneOfQStringValid);

    QCOMPARE(patchRequest.isOneOfQStringSet(), isOneOfQStringSet);

    QCOMPARE(patchRequest.getOneOfBool(), getOneOfBool);

    QCOMPARE(patchRequest.isOneOfBoolValid(), isOneOfBoolValid);

    QCOMPARE(patchRequest.isOneOfBoolSet(), isOneOfBoolSet);

    QCOMPARE(patchRequest.getOneOfDouble(), getOneOfDouble);

    QCOMPARE(patchRequest.isOneOfDoubleValid(), isOneOfDoubleValid);

    QCOMPARE(patchRequest.isOneOfDoubleSet(), isOneOfDoubleSet);

    QCOMPARE(patchRequest.isValid(), isValid);

    QCOMPARE(patchRequest.isSet(), isSet);

void OneOfTest::testPolymorphedRequestBody_data()

    QTest::addColumn<SchemasModelsOneOf::PostFarmPet_request>("pet");

    QTest::addColumn<SchemasModelsOneOf::Dog>("dog");

    QTest::addColumn<SchemasModelsOneOf::Duck>("duck");

    QTest::addColumn<SchemasModelsOneOf::Bunny>("bunny");

    QTest::addColumn<OneOfTest::FarmApiMode>("mode");

    QTest::addColumn<QString>("expectedJson");

    // Empty

    QTest::newRow("empty duck, bunny, dog and farm pet")

        << SchemasModelsOneOf::PostFarmPet_request{}

        << SchemasModelsOneOf::Dog{}

        << SchemasModelsOneOf::Duck{}

        << SchemasModelsOneOf::Bunny{}

        << OneOfTest::FarmApiMode::UsePostPet

        << QString("{}"_L1);

    SchemasModelsOneOf::PostFarmPet_request model;

    SchemasModelsOneOf::Duck duck;

    duck.setHunts(true);

    duck.setAge(9);

    SchemasModelsOneOf::Bunny bunny;

    bunny.setBreedType("Wild"_L1);

    bunny.setWeight(5);

    QTest::newRow("Set Bunny object")

        << SchemasModelsOneOf::PostFarmPet_request{}

        << SchemasModelsOneOf::Dog{}

        << SchemasModelsOneOf::Duck{}

        << bunny

        << OneOfTest::FarmApiMode::UseBunny

        << QString("{\"breed-type\":\"Wild\",\"weight\":5}"_L1);

    QTest::newRow("Set Duck object")

        << SchemasModelsOneOf::PostFarmPet_request{}

        << SchemasModelsOneOf::Dog{}

        << duck

        << SchemasModelsOneOf::Bunny{}

        << OneOfTest::FarmApiMode::UseDuck

        << QString("{\"age\":9,\"hunts\":true}"_L1);

    model.setOneOfDuck(duck);

    QTest::newRow("Set PostFarmPet_request object with duck data")

        << model

        << SchemasModelsOneOf::Dog{}

        << SchemasModelsOneOf::Duck{}

        << SchemasModelsOneOf::Bunny{}

        << OneOfTest::FarmApiMode::UsePostPet

        << QString("{\"age\":9,\"hunts\":true}"_L1);

    model.setOneOfBunny(bunny);

    QTest::newRow("Set PostFarmPet_request object with bunny data")

        << model

        << SchemasModelsOneOf::Dog{}

        << SchemasModelsOneOf::Duck{}

        << SchemasModelsOneOf::Bunny{}

        << OneOfTest::FarmApiMode::UsePostPet

        << QString("{\"breed-type\":\"Wild\",\"weight\":5}"_L1);

    model.setOneOfBunny(SchemasModelsOneOf::Bunny{});

    QTest::newRow("Reset PostFarmPet_request object to empty")

        << model

        << SchemasModelsOneOf::Dog{}

        << SchemasModelsOneOf::Duck{}

        << SchemasModelsOneOf::Bunny{}

        << OneOfTest::FarmApiMode::UsePostPet

        << QString("{}"_L1);

    SchemasModelsOneOf::Dog dog;

    dog.setBreed("Dingo"_L1);

    // Should fail because bark is not set, but bark is required

    QTest::newRow("Set incomplete Dog() object")

        << SchemasModelsOneOf::PostFarmPet_request{}

        << dog

        << SchemasModelsOneOf::Duck{}

        << SchemasModelsOneOf::Bunny{}

        << OneOfTest::FarmApiMode::UseDog

        << QString("{}"_L1);

    dog.setBark(true);

    QTest::newRow("Set full Dog() object")

        << SchemasModelsOneOf::PostFarmPet_request{}

        << dog

        << SchemasModelsOneOf::Duck{}

        << SchemasModelsOneOf::Bunny{}

        << OneOfTest::FarmApiMode::UseDog

        << QString("{\"bark\":true,\"breed\":\"Dingo\"}"_L1);

void OneOfTest::testPolymorphedRequestBody()

    QFETCH(SchemasModelsOneOf::PostFarmPet_request, pet);

    QFETCH(SchemasModelsOneOf::Dog, dog);

    QFETCH(SchemasModelsOneOf::Duck, duck);

    QFETCH(SchemasModelsOneOf::Bunny, bunny);

    QFETCH(OneOfTest::FarmApiMode, mode);

    QFETCH(QString, expectedJson);

    bool done = true;

    SchemasModelsOneOf::FarmApi farmApi;

    LoggingNetworkAccessManager logging(&farmApi);

    QRestAccessManager restManager(&logging, &farmApi);

    farmApi.setRestAccessManager(&restManager);

    switch (mode) {

    case OneOfTest::FarmApiMode::UsePostPet:

        farmApi.postFarmPet(pet, this, [&](const QRestReply &reply) {

            done = reply.isSuccess();

});

    } break;

    case OneOfTest::FarmApiMode::UseDuck:

        farmApi.postFarmPet(duck, this, [&](const QRestReply &reply) {

            done = reply.isSuccess();

});

    } break;

    case OneOfTest::FarmApiMode::UseBunny:

        farmApi.postFarmPet(bunny, this, [&](const QRestReply &reply) {

            done = reply.isSuccess();

});

    } break;

    case OneOfTest::FarmApiMode::UseDog:

        farmApi.postFarmPet(dog, this, [&](const QRestReply &reply) {

            done = reply.isSuccess();

});

    } break;

    QCOMPARE(logging.m_content, expectedJson);

    QTRY_COMPARE_EQ(done, false);

void OneOfTest::testPostAccountRequestJsonConversionMethods_data()

    QTest::addColumn<SchemasModelsOneOf::PostAccount_request>("postAccountRequest");

    QTest::addColumn<QString>("expectedJson");

    QTest::addColumn<QJsonValue>("expectedJsonValue");

    QTest::addColumn<QString>("oneOf0ExpectedJson");

    QTest::addColumn<QString>("oneOf1ExpectedJson");

    QTest::addColumn<bool>("isOneOf0Valid");

    QTest::addColumn<bool>("isOneOf0Set");

    QTest::addColumn<bool>("isOneOf1Valid");

    QTest::addColumn<bool>("isOneOf1Set");

    QTest::addColumn<bool>("isValid");

    QTest::addColumn<bool>("isSet");

    // PostAccount_request has two oneOf alternatives:

    // oneOf0: Account (which is itself a oneOf - see testAccountJsonConversionMethods)

    // oneOf1: QMap<QString, QJsonValue> (object with additionalProperties: true)

//

    // An empty Account is a oneOf with nothing set => Account.isValid() = false

    // An empty QMap is valid for additionalProperties: true (no required properties)

    SchemasModelsOneOf::PostAccount_request postAccountRequest;

    QTest::newRow("Empty PostAccount_request object")

        // postAccountRequest             // expectedJson

        << postAccountRequest             << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Set a valid Account via setter (Account with Account_oneOf set)

    SchemasModelsOneOf::Account validAccount;

    SchemasModelsOneOf::Account_oneOf acctData;

    acctData.setName("Test Corp"_L1);

    acctData.setContractAvailable(true);

    validAccount.setOneOfAccount_oneOf(acctData);

    postAccountRequest.setOneOfAccount(validAccount);

    QTest::newRow("Set a valid Account (with Account_oneOf) via setter")

        // postAccountRequest             // expectedJson

        << postAccountRequest             << validAccount.asJson()

        // expectedJsonValue

        << validAccount.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << validAccount.asJson()          << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << true                           << true

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set a valid Account via setter (Account with Account_oneOf_1 set)

    SchemasModelsOneOf::Account validAccount2;

    SchemasModelsOneOf::Account_oneOf_1 acctData2;

    acctData2.setFirstname("Jane"_L1);

    acctData2.setLastname("Doe"_L1);

    validAccount2.setOneOfAccount_oneOf_1(acctData2);

    postAccountRequest.setOneOfAccount(validAccount2);

    QTest::newRow("Set a valid Account (with Account_oneOf_1) via setter")

        // postAccountRequest             // expectedJson

        << postAccountRequest             << validAccount2.asJson()

        // expectedJsonValue

        << validAccount2.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << validAccount2.asJson()          << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << true                           << true

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set a QMap (additionalProperties object) via setter

    QMap<QString, QJsonValue> freeformObj;

    freeformObj.insert("customField1"_L1, QJsonValue("value1"_L1));

    freeformObj.insert("customField2"_L1, QJsonValue(42));

    freeformObj.insert("nested"_L1, QJsonValue(true));

    postAccountRequest.setOneOfQMapQStringQJsonValue(freeformObj);

    const QString expectedTestString(

        "{\"customField1\":\"value1\",\"customField2\":42,\"nested\":true}"_L1);

    QTest::newRow("Set a valid QMap via setter")

        // postAccountRequest             // expectedJson

        << postAccountRequest             << expectedTestString

        // expectedJsonValue

        << postAccountRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << expectedTestString

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // Set an empty QMap via setter - empty map should still be valid

    const QMap<QString, QJsonValue> emptyMap;

    postAccountRequest.setOneOfQMapQStringQJsonValue(emptyMap);

    QTest::newRow("Set an empty QMap via setter")

        // postAccountRequest             // expectedJson

        << postAccountRequest             << postAccountRequest.asJson()

        // expectedJsonValue

        << postAccountRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // Set an empty Account (which is itself invalid - no alternative selected)

    // NOTE: Account itself is also a OneOf type object! If it is empty, it doesn't

    // hold any type inside and cannot be valid.

    const SchemasModelsOneOf::Account emptyAccount;

    postAccountRequest.setOneOfAccount(emptyAccount);

    QTest::newRow("Set an empty Account via setter")

        // postAccountRequest             // expectedJson

        << postAccountRequest             << emptyAccount.asJson()

        // expectedJsonValue

        << emptyAccount.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // fromJson with Account_oneOf data (name field identifies it)

    const QString acctJson("{\"contractAvailable\":true,\"name\":\"FromJson Corp\"}"_L1);

    postAccountRequest.fromJson(acctJson);

    QTest::newRow("Set Account_oneOf data via ::fromJson()")

        // postAccountRequest             // expectedJson

        << postAccountRequest             << acctJson

        // expectedJsonValue

        << postAccountRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << acctJson                       << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << true                           << true

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson with Account_oneOf_1 data (firstname/lastname fields)

    const QString nameJson("{\"firstname\":\"Bob\",\"lastname\":\"Jones\"}"_L1);

    postAccountRequest.fromJson(nameJson);

    QTest::newRow("Set Account_oneOf_1 data via ::fromJson()")

        // postAccountRequest             // expectedJson

        << postAccountRequest             << nameJson

        // expectedJsonValue

        << postAccountRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << nameJson                       << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << true                           << true

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson with freeform object data (fields that don't match Account)

    const QString freeformJson("{\"arbitraryKey\":\"arbitraryValue\",\"number\":99}"_L1);

    postAccountRequest.fromJson(freeformJson);

    QTest::newRow("Set freeform object data via ::fromJson()")

            // postAccountRequest             // expectedJson

            << postAccountRequest             << postAccountRequest.asJson()

            // expectedJsonValue

            << postAccountRequest.asJsonValue()

            // oneOf0ExpectedJson

            << QString("{}"_L1)

            // oneOf1ExpectedJson

            << freeformJson

            // isOneOf0Valid                      // isOneOf0Set

            << false                              << false

            // isOneOf1Valid                      // isOneOf1Set

            << true                               << true

            // isValid                            // isSet

            << true                               << true;

    // fromJsonValue with valid Account

    postAccountRequest.fromJsonValue(validAccount.asJsonValue());

    QTest::newRow("Set a valid Account via ::fromJsonValue()")

        // postAccountRequest             // expectedJson

        << postAccountRequest             << validAccount.asJson()

        // expectedJsonValue

        << postAccountRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << validAccount.asJson()          << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << true                           << true

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // invalid json! => the model is RESET to INITIAL state

    postAccountRequest.fromJson("{invalid json}"_L1);

    QTest::newRow("Set an invalid json via ::fromJson()")

        // postAccountRequest             // expectedJson

        << postAccountRequest             << QString("{}"_L1)

        // expectedJsonValue

        << postAccountRequest.asJsonValue()

        // oneOf0ExpectedJson

        << QString("{}"_L1)

        // oneOf1ExpectedJson

        << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Test with non-object JSON (array) => reset

    postAccountRequest.fromJson("[]"_L1);

    QTest::newRow("PostAccount_request: set an unexpected array via ::fromJson()")

        // postAccountRequest             // expectedJson

        << postAccountRequest             << QString("{}"_L1)

        // expectedJsonValue

        << postAccountRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Test with non-object JSON (string) => reset

    postAccountRequest.fromJson("\"string\""_L1);

    QTest::newRow("Set an unexpected string via ::fromJson()")

        // postAccountRequest             // expectedJson

        << postAccountRequest             << QString("{}"_L1)

        // expectedJsonValue

        << postAccountRequest.asJsonValue()

        // oneOf0ExpectedJson

        << QString("{}"_L1)

        // oneOf1ExpectedJson

        << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << false                          << false

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // fromJson with empty object "{}" => Account (oneOf0) has both alternatives

    // with no required fields, so empty Account resolves internally. But Account

    // itself needs a selected alternative to be valid. The QMap (oneOf1) is always

    // valid with empty. This is ambiguous. Account is selected because it is first.

    postAccountRequest.fromJson("{}"_L1);

    QTest::newRow("Set an empty object {} via ::fromJson()")

        // postAccountRequest             // expectedJson

        << postAccountRequest             << postAccountRequest.asJson()

        // expectedJsonValue

        << postAccountRequest.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // isOneOf0Valid                  // isOneOf0Set

        << true                           << true

        // isOneOf1Valid                  // isOneOf1Set

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

void OneOfTest::testPostAccountRequestJsonConversionMethods()

    QFETCH(SchemasModelsOneOf::PostAccount_request, postAccountRequest);

    QFETCH(QString, expectedJson);

    QFETCH(QJsonValue, expectedJsonValue);

    QFETCH(QString, oneOf0ExpectedJson);

    QFETCH(QString, oneOf1ExpectedJson);

    QFETCH(bool, isOneOf0Valid);

    QFETCH(bool, isOneOf0Set);

    QFETCH(bool, isOneOf1Valid);

    QFETCH(bool, isOneOf1Set);

    QFETCH(bool, isValid);

    QFETCH(bool, isSet);

    QCOMPARE(postAccountRequest.asJson(), expectedJson);

    QCOMPARE(postAccountRequest.asJsonValue(), expectedJsonValue);

    QCOMPARE(postAccountRequest.getOneOfAccount().asJson(), oneOf0ExpectedJson);

    QCOMPARE(mapAsString(postAccountRequest.getOneOfQMapQStringQJsonValue()), oneOf1ExpectedJson);

    QCOMPARE(postAccountRequest.isOneOfAccountValid(), isOneOf0Valid);

    QCOMPARE(postAccountRequest.isOneOfAccountSet(), isOneOf0Set);

    QCOMPARE(postAccountRequest.isOneOfQMapQStringQJsonValueValid(), isOneOf1Valid);

    QCOMPARE(postAccountRequest.isOneOfQMapQStringQJsonValueSet(), isOneOf1Set);

    QCOMPARE(postAccountRequest.isValid(), isValid);

    QCOMPARE(postAccountRequest.isSet(), isSet);

void OneOfTest::testPostFarmPetRequestJsonConversionMethods_data()

    QTest::addColumn<SchemasModelsOneOf::PostFarmPet_request>("postFarmPetRequest");

    QTest::addColumn<QString>("expectedJson");

    QTest::addColumn<QJsonValue>("expectedJsonValue");

    QTest::addColumn<QString>("oneOfBunnyExpectedJson");

    QTest::addColumn<QString>("oneOfDuckExpectedJson");

    QTest::addColumn<QString>("oneOfDogExpectedJson");

    QTest::addColumn<SchemasModelsOneOf::Bunny>("getOneOfBunny");

    QTest::addColumn<SchemasModelsOneOf::Duck>("getOneOfDuck");

    QTest::addColumn<SchemasModelsOneOf::Dog>("getOneOfDog");

    QTest::addColumn<bool>("isOneOfBunnyValid");

    QTest::addColumn<bool>("isOneOfBunnySet");

    QTest::addColumn<bool>("isOneOfDuckValid");

    QTest::addColumn<bool>("isOneOfDuckSet");

    QTest::addColumn<bool>("isOneOfDogValid");

    QTest::addColumn<bool>("isOneOfDogSet");

    QTest::addColumn<bool>("isValid");

    QTest::addColumn<bool>("isSet");

    SchemasModelsOneOf::PostFarmPet_request req;

    QTest::newRow("Empty PostFarmPet_request object")

        // postFarmPetRequest             // expectedJson

        << req                            << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                  // getOneOfDuck

        << SchemasModelsOneOf::Bunny()    << SchemasModelsOneOf::Duck()

        // getOneOfDog

        << SchemasModelsOneOf::Dog()

        // isOneOfBunnyValid              // isOneOfBunnySet

        << false                          << false

        // isOneOfDuckValid               // isOneOfDuckSet

        << false                          << false

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // no required fields

    SchemasModelsOneOf::Bunny bunny;

    bunny.setWeight(5);

    bunny.setBreedType("Himalayan"_L1);

    // no required fields

    SchemasModelsOneOf::Duck duck;

    duck.setHunts(false);

    duck.setAge(7);

    // has required 'bark' - bool

    SchemasModelsOneOf::Dog hund;

    hund.setBark(false);

    hund.setBreed("French Bulldog"_L1);

    // check setters work fine with valid objects

    req.setOneOfBunny(bunny);

    QTest::newRow("Set a valid Bunny object via setter")

        // postFarmPetRequest             // expectedJson

        << req                            << bunny.asJson()

        // expectedJsonValue

        << bunny.asJsonValue()

        // oneOfBunnyExpectedJson

        << bunny.asJson()

        // oneOfDuckExpectedJson             // oneOfDogExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // getOneOfBunny                  // getOneOfDuck

        << bunny                          << SchemasModelsOneOf::Duck()

        // getOneOfDog

        << SchemasModelsOneOf::Dog()

        // isOneOfBunnyValid              // isOneOfBunnySet

        << true                           << true

        // isOneOfDuckValid               // isOneOfDuckSet

        << false                          << false

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    req.setOneOfDuck(duck);

    QTest::newRow("Set a valid Duck object via setter")

        // postFarmPetRequest             // expectedJson

        << req                            << duck.asJson()

        // expectedJsonValue

        << duck.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << duck.asJson()

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                  // getOneOfDuck

        << SchemasModelsOneOf::Bunny()    << duck

        // getOneOfDog

        << SchemasModelsOneOf::Dog()

        // isOneOfBunnyValid              // isOneOfBunnySet

        << false                          << false

        // isOneOfDuckValid               // isOneOfDuckSet

        << true                           << true

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    req.setOneOfDog(hund);

    QTest::newRow("Set a valid Dog object via setter")

        // postFarmPetRequest             // expectedJson

        << req                            << hund.asJson()

        // expectedJsonValue

        << hund.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // oneOfDogExpectedJson

        << hund.asJson()

        // getOneOfBunny                  // getOneOfDuck

        << SchemasModelsOneOf::Bunny()    << SchemasModelsOneOf::Duck()

        // getOneOfDog

        << hund

        // isOneOfBunnyValid              // isOneOfBunnySet

        << false                          << false

        // isOneOfDuckValid               // isOneOfDuckSet

        << false                          << false

        // isOneOfDogValid                // isOneOfDogSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // Set an empty Dog object, the dog has required fields, so an empty

    // dog is INVALID => entire PostFarmPet_request stays invalid

    const SchemasModelsOneOf::Dog emptyDog;

    req.setOneOfDog(emptyDog);

    QTest::newRow("Set an empty Dog object via setter")

        // postFarmPetRequest             // expectedJson

        << req                            << emptyDog.asJson()

        // expectedJsonValue

        << emptyDog.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                  // getOneOfDuck

        << SchemasModelsOneOf::Bunny()    << SchemasModelsOneOf::Duck()

        // getOneOfDog

        << emptyDog

        // isOneOfBunnyValid              // isOneOfBunnySet

        << false                          << false

        // isOneOfDuckValid               // isOneOfDuckSet

        << false                          << false

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Set an empty Bunny object, the bunny has no required fields, so an empty

    // bunny is VALID => entire PostFarmPet_request becomes valid

    const SchemasModelsOneOf::Bunny emptyBunny;

    req.setOneOfBunny(emptyBunny);

    QTest::newRow("Set an empty Bunny object via setter")

        // postFarmPetRequest             // expectedJson

        << req                            << emptyBunny.asJson()

        // expectedJsonValue

        << emptyBunny.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                  // getOneOfDuck

        << emptyBunny                     << SchemasModelsOneOf::Duck()

        // getOneOfDog

        << SchemasModelsOneOf::Dog()

        // isOneOfBunnyValid              // isOneOfBunnySet

        << true                           << true

        // isOneOfDuckValid               // isOneOfDuckSet

        << false                          << false

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set an empty Duck object, the duck has no required fields, so an empty

    // duck is VALID => entire PostFarmPet_request becomes valid

    const SchemasModelsOneOf::Duck emptyDuck;

    req.setOneOfDuck(emptyDuck);

    QTest::newRow("Set an empty Duck object via setter")

        // postFarmPetRequest             // expectedJson

        << req                            << emptyDuck.asJson()

        // expectedJsonValue

        << emptyDuck.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                  // getOneOfDuck

        << emptyBunny                     << emptyDuck

        // getOneOfDog

        << SchemasModelsOneOf::Dog()

        // isOneOfBunnyValid              // isOneOfBunnySet

        << false                          << false

        // isOneOfDuckValid               // isOneOfDuckSet

        << true                           << true

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue with EMPTY data.

    // Attempting to set an empty Dog via req.fromJsonValue().

    // Dog defines required field 'bark', so an empty object is INVALID for Dog.

//

    // However, emptyDog.asJsonValue() produces '{}' because it is an empty object.

//

    // The PostFarmPet_request::fromJsonValue() logic cannot determine whether '{}'

    // represents a Bunny, Duck, or Dog. The only available approach is to try

    // deserializing '{}' against each schema and select the one that validates

    // successfully.

//

    // This leads to ambiguity, since '{}' is valid for both Bunny and Duck

    // (neither has required fields). Bunny is first, so it wins.

//

    // To avoid such situations, the schema should define either a discriminator

    // or required fields for each Object in the YAML specification.

//

    // This ambiguity is intentional here for testing purposes, to highlight

    // the importance of well-defined API schemas. Ensuring correctness of the

    // API design is the responsibility of the API author.

    req.fromJsonValue(emptyDog.asJsonValue());

    QTest::newRow("Set an empty Dog via ::fromJsonValue(emptyDog.asJsonValue())")

        // postFarmPetRequest             // expectedJson

        << req                            << emptyDog.asJson()

        // expectedJsonValue

        << emptyDog.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                  // getOneOfDuck

        << emptyBunny                     << emptyDuck

        // getOneOfDog

        << emptyDog

        // !!! NOTE: ambiguity between Bunny and Duck resolved to Bunny

        // (because it's first in the list)

        // isOneOfBunnyValid              // isOneOfBunnySet

        << true                           << true

        // isOneOfDuckValid               // isOneOfDuckSet

        << false                          << false

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson with EMPTY data. Same expectations as with

    // 'Set an empty Dog via req.fromJsonValue(emptyDog.asJsonValue())'

    req.fromJson(emptyDog.asJson());

    QTest::newRow("Set an empty Dog via ::fromJson(emptyDog.asJson())")

        // postFarmPetRequest             // expectedJson

        << req                            << emptyDog.asJson()

        // expectedJsonValue

        << emptyDog.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                  // getOneOfDuck

        << emptyBunny                     << emptyDuck

        // getOneOfDog

        << emptyDog

        // !!! NOTE: ambiguity between Bunny and Duck, Bunny wins

        // isOneOfBunnyValid              // isOneOfBunnySet

        << true                           << true

        // isOneOfDuckValid               // isOneOfDuckSet

        << false                          << false

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // ::fromJson with EMPTY Bunny data. Same expectations as above.

    req.fromJson(emptyBunny.asJson());

    QTest::newRow("Set an empty Bunny via ::fromJson(emptyBunny.asJson())")

        // postFarmPetRequest             // expectedJson

        << req                            << emptyBunny.asJson()

        // expectedJsonValue

        << emptyBunny.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                  // getOneOfDuck

        << emptyBunny                     << emptyDuck

        // getOneOfDog

        << emptyDog

        // isOneOfBunnyValid              // isOneOfBunnySet

        << true                           << true

        // isOneOfDuckValid               // isOneOfDuckSet

        << false                          << false

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    req.fromJsonValue(emptyBunny.asJsonValue());

    QTest::newRow("Set an empty Bunny via ::fromJsonValue(emptyBunny.asJsonValue())")

        // postFarmPetRequest             // expectedJson

        << req                            << emptyBunny.asJson()

        // expectedJsonValue

        << emptyBunny.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                  // getOneOfDuck

        << emptyBunny                     << emptyDuck

        // getOneOfDog

        << emptyDog

        // isOneOfBunnyValid              // isOneOfBunnySet

        << true                           << true

        // isOneOfDuckValid               // isOneOfDuckSet

        << false                          << false

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    const QString bunnyWeight("{\"weight\":5}"_L1);

    req.fromJson(bunnyWeight);

    QTest::newRow("Set a valid Bunny object via ::fromJson()")

        // postFarmPetRequest             // expectedJson

        << req                            << bunnyWeight

        // expectedJsonValue

        << req.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << bunnyWeight                    << QString("{}"_L1)

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                         // getOneOfDuck

        << SchemasModelsOneOf::Bunny(bunnyWeight) << emptyDuck

        // getOneOfDog

        << emptyDog

        // isOneOfBunnyValid              // isOneOfBunnySet

        << true                           << true

        // isOneOfDuckValid               // isOneOfDuckSet

        << false                          << false

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // check fromJsonValue() works fine for VALID bunny object

    const SchemasModelsOneOf::Bunny okBunny(bunnyWeight);

    req.fromJsonValue(okBunny.asJsonValue());

    QTest::newRow("Set a valid Bunny object via ::fromJsonValue()")

        // postFarmPetRequest             // expectedJson

        << req                            << bunnyWeight

        // expectedJsonValue

        << req.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << bunnyWeight                    << QString("{}"_L1)

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                         // getOneOfDuck

        << SchemasModelsOneOf::Bunny(bunnyWeight) << emptyDuck

        // getOneOfDog

        << emptyDog

        // isOneOfBunnyValid              // isOneOfBunnySet

        << true                           << true

        // isOneOfDuckValid               // isOneOfDuckSet

        << false                          << false

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // check fromJson() works fine for VALID duck object

    const QString duckyDuck("{\"age\":7,\"hunts\":false}"_L1);

    req.fromJson(duckyDuck);

    QTest::newRow("Set a valid Duck object via ::fromJson()")

        // postFarmPetRequest             // expectedJson

        << req                            << duckyDuck

        // expectedJsonValue

        << req.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << duckyDuck

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                  // getOneOfDuck

        << emptyBunny                     << SchemasModelsOneOf::Duck(duckyDuck)

        // getOneOfDog

        << emptyDog

        // isOneOfBunnyValid              // isOneOfBunnySet

        << false                          << false

        // isOneOfDuckValid               // isOneOfDuckSet

        << true                           << true

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // check ::fromJsonValue() works fine for VALID duck object

    const SchemasModelsOneOf::Duck okDuck(duckyDuck);

    req.fromJsonValue(okDuck.asJsonValue());

    QTest::newRow("Set a valid Duck object via ::fromJsonValue()")

        // postFarmPetRequest             // expectedJson

        << req                            << duckyDuck

        // expectedJsonValue

        << req.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << duckyDuck

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                  // getOneOfDuck

        << emptyBunny                     << SchemasModelsOneOf::Duck(duckyDuck)

        // getOneOfDog

        << emptyDog

        // isOneOfBunnyValid              // isOneOfBunnySet

        << false                          << false

        // isOneOfDuckValid               // isOneOfDuckSet

        << true                           << true

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // check fromJson() works fine for VALID dog object

    const QString doggyDog("{\"bark\":false}"_L1);

    req.fromJson(doggyDog);

    QTest::newRow("Set a valid Dog object via ::fromJson()")

        // postFarmPetRequest             // expectedJson

        << req                            << doggyDog

        // expectedJsonValue

        << req.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // oneOfDogExpectedJson

        << doggyDog

        // getOneOfBunny                  // getOneOfDuck

        << emptyBunny                     << emptyDuck

        // getOneOfDog

        << SchemasModelsOneOf::Dog(doggyDog)

        // isOneOfBunnyValid              // isOneOfBunnySet

        << false                          << false

        // isOneOfDuckValid               // isOneOfDuckSet

        << false                          << false

        // isOneOfDogValid                // isOneOfDogSet

        << true                           << true

        // isValid                       // isSet

        << true                           << true;

    // check fromJsonValue() works fine for VALID dog object

    const SchemasModelsOneOf::Dog okDog(doggyDog);

    req.fromJsonValue(okDog.asJsonValue());

    QTest::newRow("Set a valid Dog object via ::fromJsonValue()")

        // postFarmPetRequest             // expectedJson

        << req                            << doggyDog

        // expectedJsonValue

        << req.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // oneOfDogExpectedJson

        << doggyDog

        // getOneOfBunny                  // getOneOfDuck

        << emptyBunny                     << emptyDuck

        // getOneOfDog

        << SchemasModelsOneOf::Dog(doggyDog)

        // isOneOfBunnyValid              // isOneOfBunnySet

        << false                          << false

        // isOneOfDuckValid               // isOneOfDuckSet

        << false                          << false

        // isOneOfDogValid                // isOneOfDogSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // invalid json! => the model is RESET to INITIAL state

    req.fromJson("{invalid json}"_L1);

    QTest::newRow("Set an invalid json via ::fromJson()")

        // postFarmPetRequest             // expectedJson

        << req                            << QString("{}"_L1)

        // expectedJsonValue

        << req.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                  // getOneOfDuck

        << emptyBunny                     << emptyDuck

        // getOneOfDog

        << emptyDog

        // isOneOfBunnyValid              // isOneOfBunnySet

        << false                          << false

        // isOneOfDuckValid               // isOneOfDuckSet

        << false                          << false

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Test with non-object JSON (array) => the model is RESET to INITIAL state

    req.fromJson("[]"_L1);

    QTest::newRow("Set an unexpected array [] via ::fromJson()")

        // postFarmPetRequest             // expectedJson

        << req                            << QString("{}"_L1)

        // expectedJsonValue

        << req.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                  // getOneOfDuck

        << emptyBunny                     << emptyDuck

        // getOneOfDog

        << emptyDog

        // isOneOfBunnyValid              // isOneOfBunnySet

        << false                          << false

        // isOneOfDuckValid               // isOneOfDuckSet

        << false                          << false

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Test with non-object JSON (string) => the model is RESET to INITIAL state

    req.fromJson("\"just a string\""_L1);

    QTest::newRow("Set an unexpected string via ::fromJson()")

        // postFarmPetRequest             // expectedJson

        << req                            << QString("{}"_L1)

        // expectedJsonValue

        << req.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                  // getOneOfDuck

        << emptyBunny                     << emptyDuck

        // getOneOfDog

        << emptyDog

        // isOneOfBunnyValid              // isOneOfBunnySet

        << false                          << false

        // isOneOfDuckValid               // isOneOfDuckSet

        << false                          << false

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Missing Required Fields (Dog's 'bark' is required)

    // Dog without required 'bark' field - should not be valid

    SchemasModelsOneOf::Dog invalidDog;

    invalidDog.setBreed("Husky-kolbasky"_L1);

    req.setOneOfDog(invalidDog);

    QTest::newRow("Set an invalid Dog via setter")

        // postFarmPetRequest             // expectedJson

        << req                            << QString("{}"_L1)

        // expectedJsonValue

        << req.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // oneOfDogExpectedJson

        << invalidDog.asJson()

        // getOneOfBunny                  // getOneOfDuck

        << emptyBunny                     << emptyDuck

        // getOneOfDog

        << invalidDog

        // isOneOfBunnyValid              // isOneOfBunnySet

        << false                          << false

        // isOneOfDuckValid               // isOneOfDuckSet

        << false                          << false

        // The status here reflects the status of the model that was set.

        // The model's field was set by setter, so invalidDog.isSet() == true

        // but invalidDog.isValid() == false, because required field is not set.

        // isOneOfDogValid                // isOneOfDogSet

        << invalidDog.isValid()           << invalidDog.isSet()

        // isValid                        // isSet

        << false                          << true;

    // Try to parse JSON with only 'breed' field

    // Dog also has 'breed', but bark is missing => Dog is invalid.

    const QString testValue("{\"breed\":\"Retriever\"}"_L1);

    req.fromJson(testValue);

    QTest::newRow("Set a breed-only Dog JSON via ::fromJson()")

        // postFarmPetRequest             // expectedJson

        << req                            << QString("{}"_L1)

        // expectedJsonValue

        << req.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // oneOfDogExpectedJson

        << testValue

        // getOneOfBunny                  // getOneOfDuck

        << emptyBunny                     << emptyDuck

        // getOneOfDog

        << SchemasModelsOneOf::Dog(testValue)

        // isOneOfBunnyValid              // isOneOfBunnySet

        << false                          << false

        // isOneOfDuckValid               // isOneOfDuckSet

        << false                          << false

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << true

        // isValid                        // isSet

        << false                          << true;

    // Partial/Incomplete JSON Objects

    // Only weight field for Bunny (without breed-type),

    // should work since Bunny has no required fields

    const QString notFullBunny("{\"weight\":3}"_L1);

    req.fromJson(notFullBunny);

    QTest::newRow("Set a valid non-full Bunny via ::fromJson()")

        // postFarmPetRequest             // expectedJson

        << req                            << notFullBunny

        // expectedJsonValue

        << req.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << notFullBunny                   << QString("{}"_L1)

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                          // getOneOfDuck

        << SchemasModelsOneOf::Bunny(notFullBunny) << emptyDuck

        // getOneOfDog

        << emptyDog

        // isOneOfBunnyValid              // isOneOfBunnySet

        << true                           << true

        // isOneOfDuckValid               // isOneOfDuckSet

        << false                          << false

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Extra/Unknown Fields in JSON

    // JSON with fields not in schema - should parse known fields and ignore unknown

    // Using Duck fields + unknown fields to avoid breed ambiguity with Dog

    req.fromJson("{\"age\":7,\"hunts\":false,\"name\":\"Donald\",\"color\":\"white\"}"_L1);

    QString expected("{\"age\":7,\"hunts\":false}"_L1);

    QTest::newRow("Extra/Unknown Fields in JSON via ::fromJson()")

        // postFarmPetRequest             // expectedJson

        << req                            << expected

        // expectedJsonValue

        << req.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << expected

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                  // getOneOfDuck

        << emptyBunny                     << SchemasModelsOneOf::Duck(expected)

        // getOneOfDog

        << emptyDog

        // isOneOfBunnyValid              // isOneOfBunnySet

        << false                          << false

        // isOneOfDuckValid               // isOneOfDuckSet

        << true                           << true

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Invalid Field Types for Duck(). Wrong type for age (string instead of integer)

    // Note: fields of Duck type are not required, it means wrong fields can be omitted

    expected = QString("{\"age\":\"seven\",\"hunts\":false}"_L1);

    req.fromJson(expected);

    QTest::newRow("Invalid field 'age=seven' in Duck via ::fromJson()")

        // postFarmPetRequest             // expectedJson

        << req                            << QString("{\"hunts\":false}"_L1)

        // expectedJsonValue

        << req.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << QString("{\"hunts\":false}"_L1)

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                  // getOneOfDuck

        << emptyBunny                     << SchemasModelsOneOf::Duck(expected)

        // getOneOfDog

        << emptyDog

        // isOneOfBunnyValid              // isOneOfBunnySet

        << false                          << false

        // isOneOfDuckValid               // isOneOfDuckSet

        << true                           << true

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Invalid Field Types for Duck(). Wrong type for age (double instead of integer)

    // Note: fields of Duck type are not required, it means wrong fields can be omitted

    expected = QString("{\"age\":0.1,\"hunts\":true}"_L1);

    req.fromJson(expected);

    QTest::newRow("Invalid field 'age=0.1' in Duck via ::fromJson()")

        // postFarmPetRequest             // expectedJson

        << req                            << QString("{\"hunts\":true}"_L1)

        // expectedJsonValue

        << req.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << QString("{\"hunts\":true}"_L1)

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                  // getOneOfDuck

        << emptyBunny                     << SchemasModelsOneOf::Duck(expected)

        // getOneOfDog

        << emptyDog

        // isOneOfBunnyValid              // isOneOfBunnySet

        << false                          << false

        // isOneOfDuckValid               // isOneOfDuckSet

        << true                           << true

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Invalid Field Types for Duck(). Wrong type for age (bool instead of integer)

    // Note: fields of Duck type are not required, it means wrong fields can be omitted

    expected = QString("{\"age\":true,\"hunts\":true}"_L1);

    req.fromJson(expected);

    QTest::newRow("Invalid field 'age=true' in Duck via ::fromJson()")

        // postFarmPetRequest             // expectedJson

        << req                            << QString("{\"hunts\":true}"_L1)

        // expectedJsonValue

        << req.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << QString("{\"hunts\":true}"_L1)

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                  // getOneOfDuck

        << emptyBunny                     << SchemasModelsOneOf::Duck(expected)

        // getOneOfDog

        << emptyDog

        // isOneOfBunnyValid              // isOneOfBunnySet

        << false                          << false

        // isOneOfDuckValid               // isOneOfDuckSet

        << true                           << true

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    expected = QString("{\"age\":true,\"hunts\":1}"_L1);

    req.fromJson(expected);

    QTest::newRow("Invalid fields: 'age=true', hunts=1 in Duck via ::fromJson()")

        // postFarmPetRequest             // expectedJson

        << req                            << QString("{}"_L1)

        // expectedJsonValue

        << req.asJsonValue()

        // oneOfBunnyExpectedJson         // oneOfDuckExpectedJson

        << QString("{}"_L1)               << QString("{}"_L1)

        // oneOfDogExpectedJson

        << QString("{}"_L1)

        // getOneOfBunny                  // getOneOfDuck

        << emptyBunny                     << emptyDuck

        // getOneOfDog

        << emptyDog

        // isOneOfBunnyValid              // isOneOfBunnySet

        << false                          << false

        // isOneOfDuckValid               // isOneOfDuckSet

        << false                          << false

        // isOneOfDogValid                // isOneOfDogSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

void OneOfTest::testPostFarmPetRequestJsonConversionMethods()

    QFETCH(SchemasModelsOneOf::PostFarmPet_request, postFarmPetRequest);

    QFETCH(QString, expectedJson);

    QFETCH(QJsonValue, expectedJsonValue);

    QFETCH(QString, oneOfBunnyExpectedJson);

    QFETCH(QString, oneOfDuckExpectedJson);

    QFETCH(QString, oneOfDogExpectedJson);

    QFETCH(SchemasModelsOneOf::Bunny, getOneOfBunny);

    QFETCH(SchemasModelsOneOf::Duck, getOneOfDuck);

    QFETCH(SchemasModelsOneOf::Dog, getOneOfDog);

    QFETCH(bool, isOneOfBunnyValid);

    QFETCH(bool, isOneOfBunnySet);

    QFETCH(bool, isOneOfDuckValid);

    QFETCH(bool, isOneOfDuckSet);

    QFETCH(bool, isOneOfDogValid);

    QFETCH(bool, isOneOfDogSet);

    QFETCH(bool, isValid);

    QFETCH(bool, isSet);

    QCOMPARE(postFarmPetRequest.asJson(), expectedJson);

    QCOMPARE(postFarmPetRequest.asJsonValue(), expectedJsonValue);

    QCOMPARE(postFarmPetRequest.getOneOfBunny().asJson(), oneOfBunnyExpectedJson);

    QCOMPARE(postFarmPetRequest.isOneOfBunnyValid(), isOneOfBunnyValid);

    QCOMPARE(postFarmPetRequest.isOneOfBunnySet(), isOneOfBunnySet);

    QCOMPARE(postFarmPetRequest.getOneOfDuck().asJson(), oneOfDuckExpectedJson);

    QCOMPARE(postFarmPetRequest.isOneOfDuckValid(), isOneOfDuckValid);

    QCOMPARE(postFarmPetRequest.isOneOfDuckSet(), isOneOfDuckSet);

    QCOMPARE(postFarmPetRequest.getOneOfDog().asJson(), oneOfDogExpectedJson);

    QCOMPARE(postFarmPetRequest.getOneOfBunny(), getOneOfBunny);

    QCOMPARE(postFarmPetRequest.getOneOfDuck(), getOneOfDuck);

    QCOMPARE(postFarmPetRequest.getOneOfDog(), getOneOfDog);

    QCOMPARE(postFarmPetRequest.isOneOfDogValid(), isOneOfDogValid);

    QCOMPARE(postFarmPetRequest.isOneOfDogSet(), isOneOfDogSet);

    QCOMPARE(postFarmPetRequest.isValid(), isValid);

    QCOMPARE(postFarmPetRequest.isSet(), isSet);

void OneOfTest::testDummyTestValue()

    SchemasModelsOneOf::DummyTestValue dummy;

    QCOMPARE(dummy.asJson(), "{}"_L1);

    QCOMPARE(dummy.asJsonValue(), QJsonValue(QJsonValue::Object));

    QCOMPARE(dummy.isValid(), false);

    QCOMPARE(dummy.isSet(), false);

// Helper: serialize QList<QList<qint32>> to compact JSON string

static QString listListInt32AsJson(const QList<QList<qint32>> &v)

    QJsonArray outer;

    for (const auto &inner : v) {

        QJsonArray arr;

        for (const auto &i : inner)

            arr.append(i);

        outer.append(arr);

    return QString::fromUtf8(QJsonValue(outer).toJson(QJsonDocument::Compact));

void OneOfTest::testRootJsonConversionMethods_data()

    QTest::addColumn<SchemasModelsOneOf::Root>("root");

    QTest::addColumn<QString>("expectedJson");

    QTest::addColumn<QJsonValue>("expectedJsonValue");

    QTest::addColumn<qint32>("oneOf0ExpectedValue");

    QTest::addColumn<QString>("oneOf1ExpectedJson");

    QTest::addColumn<QString>("oneOf2ExpectedJson");

    QTest::addColumn<bool>("isOneOfQint32Valid");

    QTest::addColumn<bool>("isOneOfQint32Set");

    QTest::addColumn<bool>("isOneOfQListQListqint32Valid");

    QTest::addColumn<bool>("isOneOfQListQListqint32Set");

    QTest::addColumn<bool>("isOneOfContainerValid");

    QTest::addColumn<bool>("isOneOfContainerSet");

    QTest::addColumn<bool>("isValid");

    QTest::addColumn<bool>("isSet");

    // Root has three oneOf alternatives:

    // oneOf0: qint32                   - primitive, always valid when set

    // oneOf1: QList<QList<qint32>>     - nested list, always valid when set

    // oneOf2: Container                - object, valid if Container is valid

    SchemasModelsOneOf::Root root;

    QTest::newRow("Empty Root object")

        // root                         // expectedJson

        << root                         << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << false                        << false

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << false                        << false;

    // Set a valid qint32 via setter

    root.setOneOfQint32(42);

    QTest::newRow("Set qint32=42 via setter")

        // root                         // expectedJson

        << root                         << QString("42"_L1)

        // expectedJsonValue

        << QJsonValue(42)

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(42)                   << QString("[]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << true                         << true

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << true                         << true;

    // Set qint32 = 0 via setter (zero is a legitimate value)

    root.setOneOfQint32(0);

    QTest::newRow("Set qint32=0 via setter")

        // root                         // expectedJson

        << root                         << QString("0"_L1)

        // expectedJsonValue

        << QJsonValue(0)

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << true                         << true

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << true                         << true;

    // Set negative qint32 via setter

    root.setOneOfQint32(-7);

    QTest::newRow("Set qint32=-7 via setter")

        // root                         // expectedJson

        << root                         << QString("-7"_L1)

        // expectedJsonValue

        << QJsonValue(-7)

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(-7)                   << QString("[]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << true                         << true

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << true                         << true;

    // Set a non-empty QList<QList<qint32>> via setter

    const QList<QList<qint32>> nestedList = {{1, 2}, {3, 4}};

    root.setOneOfQListQListqint32(nestedList);

    QTest::newRow("Set QList<QList<qint32>>={{1,2},{3,4}} via setter")

        // root                         // expectedJson

        << root                         << QString("[[1,2],[3,4]]"_L1)

        // expectedJsonValue

        << QJsonValue::fromJson("[[1,2],[3,4]]")

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[[1,2],[3,4]]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << false                        << false

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << true                         << true

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << true                         << true;

    // Set an empty QList<QList<qint32>> via setter (empty list is still a valid value)

    const QList<QList<qint32>> emptyList;

    root.setOneOfQListQListqint32(emptyList);

    QTest::newRow("Set empty QList<QList<qint32>> via setter")

        // root                         // expectedJson

        << root                         << QString("[]"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonArray())

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << false                        << false

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << true                         << true

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << true                         << true;

    // Set a valid Container (Container_oneOf with Duck value) via setter

    SchemasModelsOneOf::Duck duck;

    duck.setHunts(true);

    duck.setAge(5);

    SchemasModelsOneOf::Container_oneOf containerOneOf;

    containerOneOf.setValue(duck);

    SchemasModelsOneOf::Container validContainer;

    validContainer.setOneOfContainer_oneOf(containerOneOf);

    const QString duckContainerJson("{\"value\":{\"age\":5,\"hunts\":true}}"_L1);

    root.setOneOfContainer(validContainer);

    QTest::newRow("Set valid Container (Container_oneOf with Duck) via setter")

        // root                         // expectedJson

        << root                         << duckContainerJson

        // expectedJsonValue

        << validContainer.asJsonValue()

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[]"_L1)

        // oneOf2ExpectedJson

        << duckContainerJson

        // isOneOfQint32Valid           // isOneOfQint32Set

        << false                        << false

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << true                         << true

        // isValid                      // isSet

        << true                         << true;

    // Set valid Container (QList<Dog>) via setter.

    // Root.asJson() for this case returns an array (Container serializes as array

    // when the active variant is QList<Dog>).

    SchemasModelsOneOf::Dog dogForContainer;

    dogForContainer.setBark(true);

    dogForContainer.setBreed("Lab"_L1);

    SchemasModelsOneOf::Container dogListContainer;

    dogListContainer.setOneOfQListDog({dogForContainer});

     const QString dogListContainerJson("[{\"bark\":true,\"breed\":\"Lab\"}]"_L1);

    root.setOneOfContainer(dogListContainer);

    QTest::newRow("Set valid Container (QList<Dog>) via setter")

        // root                         // expectedJson

        << root                         << dogListContainerJson

        // expectedJsonValue

        << dogListContainer.asJsonValue()

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[]"_L1)

        // oneOf2ExpectedJson

        << dogListContainerJson

        // isOneOfQint32Valid           // isOneOfQint32Set

        << false                        << false

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << true                         << true

        // isValid                      // isSet

        << true                         << true;

    // Set an empty (invalid) Container via setter.

    // Empty Container has isValid()=false and isSet()=false,

    // so Root should have Container not set and not valid.

    const SchemasModelsOneOf::Container emptyContainer;

    root.setOneOfContainer(emptyContainer);

    QTest::newRow("Set empty (invalid) Container via setter")

        // root                         // expectedJson

        << root                         << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << false                        << false

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << false                        << false;

    // fromJson: integer value

    root.fromJson("42"_L1);

    QTest::newRow("Set qint32=42 via ::fromJson()")

        // root                         // expectedJson

        << root                         << QString("42"_L1)

        // expectedJsonValue

        << QJsonValue(42)

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(42)                   << QString("[]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << true                         << true

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << true                         << true;

    // fromJson: zero integer

    root.fromJson("0"_L1);

    QTest::newRow("Set qint32=0 via ::fromJson()")

        // root                         // expectedJson

        << root                         << QString("0"_L1)

        // expectedJsonValue

        << QJsonValue(0)

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << true                         << true

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << true                         << true;

    // fromJson: negative integer

    root.fromJson("-100"_L1);

    QTest::newRow("Set qint32=-100 via ::fromJson()")

        // root                         // expectedJson

        << root                         << QString("-100"_L1)

        // expectedJsonValue

        << QJsonValue(-100)

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(-100)                 << QString("[]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << true                         << true

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << true                         << true;

    // fromJson: 3.14 => json.isDouble() but not an integer => qint32 fails => reset

    root.fromJson("3.14"_L1);

    QTest::newRow("Set double 3.14 via ::fromJson() (no double alternative)")

        // root                         // expectedJson

        << root                         << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << false                        << false

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << false                        << false;

    // fromJson: nested array [[1,2],[3,4]]

    root.fromJson("[[1,2],[3,4]]"_L1);

    QTest::newRow("Set QList<QList<qint32>> via ::fromJson()")

        // root                         // expectedJson

        << root                         << QString("[[1,2],[3,4]]"_L1)

        // expectedJsonValue

        << root.asJsonValue()

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[[1,2],[3,4]]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << false                        << false

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << true                         << true

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << true                         << true;

    // fromJson: empty array => empty QList<QList<qint32>>, valid

    root.fromJson("[]"_L1);

    QTest::newRow("Set empty array via ::fromJson() => empty QList<QList<qint32>>")

        // root                         // expectedJson

        << root                         << QString("[]"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonArray())

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << false                        << false

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << true                         << true

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << true                         << true;

    // fromJson: array of ints [1,2,3] => each element is int, not QList<qint32>

    // => QList<QList<qint32>> parse fails => reset

    root.fromJson("[1,2,3]"_L1);

    QTest::newRow("Set [1,2,3] via ::fromJson() => fails QList<QList<qint32>>")

        // root                         // expectedJson

        << root                         << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << false                        << false

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << false                        << false;

    // fromJson: Container_oneOf JSON object with a Duck value

    root.fromJson(duckContainerJson);

    QTest::newRow("Set Container (Container_oneOf with Duck) via ::fromJson()")

        // root                         // expectedJson

        << root                         << duckContainerJson

        // expectedJsonValue

        << root.asJsonValue()

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[]"_L1)

        // oneOf2ExpectedJson

        << duckContainerJson

        // isOneOfQint32Valid           // isOneOfQint32Set

        << false                        << false

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << true                         << true

        // isValid                      // isSet

        << true                         << true;

    // => Root Container is set and valid

    root.fromJson("{}"_L1);

    QTest::newRow("Set empty object {} via ::fromJson() => Container with empty object")

        // root                         // expectedJson

        << root                         << QString("{}"_L1)

        // expectedJsonValue

        << root.asJsonValue()

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << false                        << false

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << true                         << true

        // isValid                      // isSet

        << true                         << true;

    root.fromJson(dogListContainerJson);

    QTest::newRow("Set Container(QList<Dog>) JSON via ::fromJson() => no round-trip")

        // root                         // expectedJson

        << root                         << dogListContainerJson

        // expectedJsonValue

        << root.asJsonValue()

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[]"_L1)

        // oneOf2ExpectedJson

        << dogListContainerJson

        // isOneOfQint32Valid           // isOneOfQint32Set

        << false                        << false

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << true                         << true

        // isValid                      // isSet

        << true                         << true;

    // fromJson: bool value => no bool alternative => reset

    root.fromJson("true"_L1);

    QTest::newRow("Set bool 'true' via ::fromJson() => no bool alternative")

        // root                         // expectedJson

        << root                         << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << false                        << false

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << false                        << false;

    // fromJson: string value => no string alternative => reset

    root.fromJson("\"hello\""_L1);

    QTest::newRow("Set string via ::fromJson() => no string alternative")

        // root                         // expectedJson

        << root                         << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << false                        << false

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << false                        << false;

    // fromJson: invalid JSON => reset

    root.fromJson("{invalid json}"_L1);

    QTest::newRow("Set invalid JSON via ::fromJson() => reset")

        // root                         // expectedJson

        << root                         << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << false                        << false

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << false                        << false;

    // fromJson: null => reset

    root.fromJson("null"_L1);

    QTest::newRow("Set null via ::fromJson() => reset")

        // root                         // expectedJson

        << root                         << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << false                        << false

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << false                        << false;

    // fromJsonValue: integer

    root.fromJsonValue(QJsonValue(99));

    QTest::newRow("Set qint32=99 via ::fromJsonValue()")

        // root                         // expectedJson

        << root                         << QString("99"_L1)

        // expectedJsonValue

        << QJsonValue(99)

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(99)                   << QString("[]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << true                         << true

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << true                         << true;

    // fromJsonValue: nested array

    root.fromJsonValue(QJsonValue::fromJson("[[1,2],[3,4]]"));

    QTest::newRow("Set QList<QList<qint32>> via ::fromJsonValue()")

        // root                         // expectedJson

        << root                         << QString("[[1,2],[3,4]]"_L1)

        // expectedJsonValue

        << root.asJsonValue()

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[[1,2],[3,4]]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << false                        << false

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << true                         << true

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << true                         << true;

    // fromJsonValue: valid Container object

    root.fromJsonValue(validContainer.asJsonValue());

    QTest::newRow("Set valid Container via ::fromJsonValue()")

        // root                         // expectedJson

        << root                         << duckContainerJson

        // expectedJsonValue

        << root.asJsonValue()

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[]"_L1)

        // oneOf2ExpectedJson

        << duckContainerJson

        // isOneOfQint32Valid           // isOneOfQint32Set

        << false                        << false

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << true                         << true

        // isValid                      // isSet

        << true                         << true;

    // Implicit construction from qint32

    SchemasModelsOneOf::Root rootFromInt(7);

    QTest::newRow("Implicitly construct Root from qint32=7")

        // root                         // expectedJson

        << rootFromInt                  << QString("7"_L1)

        // expectedJsonValue

        << QJsonValue(7)

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(7)                    << QString("[]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << true                         << true

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << true                         << true;

    // Implicit construction from QList<QList<qint32>>

    SchemasModelsOneOf::Root rootFromList(nestedList);

    QTest::newRow("Implicitly construct Root from QList<QList<qint32>>")

        // rootFromList                 // expectedJson

        << rootFromList                 << QString("[[1,2],[3,4]]"_L1)

        // expectedJsonValue

        << rootFromList.asJsonValue()

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[[1,2],[3,4]]"_L1)

        // oneOf2ExpectedJson

        << QString("{}"_L1)

        // isOneOfQint32Valid           // isOneOfQint32Set

        << false                        << false

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << true                         << true

        // isOneOfContainerValid        // isOneOfContainerSet

        << false                        << false

        // isValid                      // isSet

        << true                         << true;

    // Implicit construction from Container

    SchemasModelsOneOf::Root rootFromContainer(validContainer);

    QTest::newRow("Implicitly construct Root from valid Container")

        // rootFromContainer            // expectedJson

        << rootFromContainer            << duckContainerJson

        // expectedJsonValue

        << rootFromContainer.asJsonValue()

        // oneOf0ExpectedValue          // oneOf1ExpectedJson

        << qint32(0)                    << QString("[]"_L1)

        // oneOf2ExpectedJson

        << duckContainerJson

        // isOneOfQint32Valid           // isOneOfQint32Set

        << false                        << false

        // isOneOfQListQListqint32Valid // isOneOfQListQListqint32Set

        << false                        << false

        // isOneOfContainerValid        // isOneOfContainerSet

        << true                         << true

        // isValid                      // isSet

        << true                         << true;

void OneOfTest::testRootJsonConversionMethods()

    QFETCH(SchemasModelsOneOf::Root, root);

    QFETCH(QString, expectedJson);

    QFETCH(QJsonValue, expectedJsonValue);

    QFETCH(qint32, oneOf0ExpectedValue);

    QFETCH(QString, oneOf1ExpectedJson);

    QFETCH(QString, oneOf2ExpectedJson);

    QFETCH(bool, isOneOfQint32Valid);

    QFETCH(bool, isOneOfQint32Set);

    QFETCH(bool, isOneOfQListQListqint32Valid);

    QFETCH(bool, isOneOfQListQListqint32Set);

    QFETCH(bool, isOneOfContainerValid);

    QFETCH(bool, isOneOfContainerSet);

    QFETCH(bool, isValid);

    QFETCH(bool, isSet);

    QCOMPARE(root.asJson(), expectedJson);

    QCOMPARE(root.asJsonValue(), expectedJsonValue);

    QCOMPARE(root.getOneOfQint32(), oneOf0ExpectedValue);

    QCOMPARE(root.isOneOfQint32Valid(), isOneOfQint32Valid);

    QCOMPARE(root.isOneOfQint32Set(), isOneOfQint32Set);

    QCOMPARE(listListInt32AsJson(root.getOneOfQListQListqint32()), oneOf1ExpectedJson);

    QCOMPARE(root.isOneOfQListQListqint32Valid(), isOneOfQListQListqint32Valid);

    QCOMPARE(root.isOneOfQListQListqint32Set(), isOneOfQListQListqint32Set);

    QCOMPARE(root.getOneOfContainer().asJson(), oneOf2ExpectedJson);

    QCOMPARE(root.isOneOfContainerValid(), isOneOfContainerValid);

    QCOMPARE(root.isOneOfContainerSet(), isOneOfContainerSet);

    QCOMPARE(root.isValid(), isValid);

    QCOMPARE(root.isSet(), isSet);

// Helper: serialize QMap<QString, QMap<QString, qint32>> to compact JSON string

static QString mapMapInt32AsJson(const QMap<QString, QMap<QString, qint32>> &v)

    QJsonObject outer;

    for (const auto &[key, innerMap] : v.asKeyValueRange()) {

        QJsonObject inner;

        for (const auto &[innerKey, val] : innerMap.asKeyValueRange())

            inner.insert(innerKey, val);

        outer.insert(key, inner);

    return QString::fromUtf8(QJsonDocument(outer).toJson(QJsonDocument::Compact));

// Helper: serialize QList<QMap<QString, qint32>> to compact JSON string

static QString listMapInt32AsJson(const QList<QMap<QString, qint32>> &v)

    QJsonArray arr;

    for (const auto &map : v) {

        QJsonObject obj;

        for (const auto &[key, val] : map.asKeyValueRange())

            obj.insert(key, val);

        arr.append(obj);

    return QString::fromUtf8(QJsonDocument(arr).toJson(QJsonDocument::Compact));

void OneOfTest::testRootMapJsonConversionMethods_data()

    QTest::addColumn<SchemasModelsOneOf::RootMap>("rootMap");

    QTest::addColumn<QString>("expectedJson");

    QTest::addColumn<QJsonValue>("expectedJsonValue");

    QTest::addColumn<QString>("oneOf0ExpectedJson");

    QTest::addColumn<QString>("oneOf1ExpectedJson");

    QTest::addColumn<bool>("isOneOfMapOfMapsValid");

    QTest::addColumn<bool>("isOneOfMapOfMapsSet");

    QTest::addColumn<bool>("isOneOfArrayOfMapsValid");

    QTest::addColumn<bool>("isOneOfArrayOfMapsSet");

    QTest::addColumn<bool>("isValid");

    QTest::addColumn<bool>("isSet");

    // RootMap has two oneOf alternatives:

    // oneOf0: QMap<QString, QMap<QString, qint32>> - map of maps

    // oneOf1: QList<QMap<QString, qint32>>         - array of maps

    SchemasModelsOneOf::RootMap rootMap;

    QTest::newRow("Empty RootMap object")

        // rootMap                        // expectedJson

        << rootMap                        << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << false                          << false

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Set a valid map-of-maps via setter

    QMap<QString, QMap<QString, qint32>> mapOfMaps;

    mapOfMaps.insert("group1"_L1, {{"a"_L1, 1}, {"b"_L1, 2}});

    mapOfMaps.insert("group2"_L1, {{"c"_L1, 3}});

    rootMap.setOneOfQMapQStringQMapQStringqint32(mapOfMaps);

    const QString mapOfMapsJson("{\"group1\":{\"a\":1,\"b\":2},\"group2\":{\"c\":3}}"_L1);

    QTest::newRow("Set valid map-of-maps via setter")

        // rootMap                        // expectedJson

        << rootMap                        << mapOfMapsJson

        // expectedJsonValue

        << rootMap.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << mapOfMapsJson                  << QString("[]"_L1)

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << true                           << true

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set an empty map-of-maps via setter (empty map is still valid)

    const QMap<QString, QMap<QString, qint32>> emptyMapOfMaps;

    rootMap.setOneOfQMapQStringQMapQStringqint32(emptyMapOfMaps);

    QTest::newRow("Set empty map-of-maps via setter")

        // rootMap                        // expectedJson

        << rootMap                        << QString("{}"_L1)

        // expectedJsonValue

        << rootMap.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << true                           << true

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set a valid array-of-maps via setter

    QList<QMap<QString, qint32>> arrayOfMaps;

    arrayOfMaps.append({{"x"_L1, 10}, {"y"_L1, 20}});

    arrayOfMaps.append({{"z"_L1, 30}});

    rootMap.setOneOfQListQMapQStringqint32(arrayOfMaps);

    const QString arrayOfMapsJson("[{\"x\":10,\"y\":20},{\"z\":30}]"_L1);

    QTest::newRow("Set valid array-of-maps via setter")

        // rootMap                        // expectedJson

        << rootMap                        << arrayOfMapsJson

        // expectedJsonValue

        << rootMap.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << arrayOfMapsJson

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << false                          << false

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // Set an empty array-of-maps via setter (empty list is still valid)

    const QList<QMap<QString, qint32>> emptyArrayOfMaps;

    rootMap.setOneOfQListQMapQStringqint32(emptyArrayOfMaps);

    QTest::newRow("Set empty array-of-maps via setter")

        // rootMap                        // expectedJson

        << rootMap                        << QString("[]"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonArray())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << false                          << false

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // Set single-entry map-of-maps via setter

    QMap<QString, QMap<QString, qint32>> singleMapOfMaps;

    singleMapOfMaps.insert("only"_L1, {{"val"_L1, 42}});

    rootMap.setOneOfQMapQStringQMapQStringqint32(singleMapOfMaps);

    const QString singleMapOfMapsJson("{\"only\":{\"val\":42}}"_L1);

    QTest::newRow("Set single-entry map-of-maps via setter")

        // rootMap                        // expectedJson

        << rootMap                        << singleMapOfMapsJson

        // expectedJsonValue

        << rootMap.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << singleMapOfMapsJson            << QString("[]"_L1)

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << true                           << true

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set single-entry array-of-maps via setter

    QList<QMap<QString, qint32>> singleArrayOfMaps;

    singleArrayOfMaps.append({{"key"_L1, 99}});

    rootMap.setOneOfQListQMapQStringqint32(singleArrayOfMaps);

    const QString singleArrayOfMapsJson("[{\"key\":99}]"_L1);

    QTest::newRow("Set single-entry array-of-maps via setter")

        // rootMap                        // expectedJson

        << rootMap                        << singleArrayOfMapsJson

        // expectedJsonValue

        << rootMap.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << singleArrayOfMapsJson

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << false                          << false

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // fromJson: valid map-of-maps JSON

    rootMap.fromJson(mapOfMapsJson);

    QTest::newRow("Set valid map-of-maps via ::fromJson()")

        // rootMap                        // expectedJson

        << rootMap                        << mapOfMapsJson

        // expectedJsonValue

        << rootMap.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << mapOfMapsJson                  << QString("[]"_L1)

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << true                           << true

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson: valid array-of-maps JSON

    rootMap.fromJson(arrayOfMapsJson);

    QTest::newRow("Set valid array-of-maps via ::fromJson()")

        // rootMap                        // expectedJson

        << rootMap                        << arrayOfMapsJson

        // expectedJsonValue

        << rootMap.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << arrayOfMapsJson

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << false                          << false

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // fromJson: empty object {} => map-of-maps

    rootMap.fromJson("{}"_L1);

    QTest::newRow("Set empty object {} via ::fromJson() => map-of-maps")

        // rootMap                        // expectedJson

        << rootMap                        << QString("{}"_L1)

        // expectedJsonValue

        << rootMap.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << true                           << true

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson: empty array [] => array-of-maps

    rootMap.fromJson("[]"_L1);

    QTest::newRow("Set empty array [] via ::fromJson() => empty array-of-maps")

        // rootMap                        // expectedJson

        << rootMap                        << QString("[]"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonArray())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << false                          << false

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // fromJson: array of ints [1,2,3] => each element is int, not a map

    // => QList<QMap<QString, qint32>> parse fails => reset

    rootMap.fromJson("[1,2,3]"_L1);

    QTest::newRow("Set [1,2,3] via ::fromJson() => fails array-of-maps")

        // rootMap                        // expectedJson

        << rootMap                        << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << false                          << false

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // fromJson: integer value => no integer alternative => reset

    rootMap.fromJson("42"_L1);

    QTest::newRow("Set integer via ::fromJson() => no integer alternative")

        // rootMap                        // expectedJson

        << rootMap                        << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << false                          << false

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // fromJson: bool value => no bool alternative => reset

    rootMap.fromJson("true"_L1);

    QTest::newRow("Set bool 'true' via ::fromJson() => no bool alternative")

        // rootMap                        // expectedJson

        << rootMap                        << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << false                          << false

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // fromJson: string value => no string alternative => reset

    rootMap.fromJson("\"hello\""_L1);

    QTest::newRow("Set string via ::fromJson() => no string alternative")

        // rootMap                        // expectedJson

        << rootMap                        << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << false                          << false

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // fromJson: invalid JSON => reset

    rootMap.fromJson("{invalid json}"_L1);

    QTest::newRow("Set invalid JSON via ::fromJson() => reset")

        // rootMap                        // expectedJson

        << rootMap                        << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << false                          << false

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // fromJson: null => reset

    rootMap.fromJson("null"_L1);

    QTest::newRow("Set null via ::fromJson() => reset")

        // rootMap                        // expectedJson

        << rootMap                        << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << false                          << false

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // fromJsonValue: valid map-of-maps object

    rootMap.fromJsonValue(QJsonValue::fromJson(mapOfMapsJson.toUtf8()));

    QTest::newRow("Set valid map-of-maps via ::fromJsonValue()")

        // rootMap                        // expectedJson

        << rootMap                        << mapOfMapsJson

        // expectedJsonValue

        << rootMap.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << mapOfMapsJson                  << QString("[]"_L1)

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << true                           << true

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue: valid array-of-maps

    rootMap.fromJsonValue(QJsonValue::fromJson(arrayOfMapsJson.toUtf8()));

    QTest::newRow("Set valid array-of-maps via ::fromJsonValue()")

        // rootMap                        // expectedJson

        << rootMap                        << arrayOfMapsJson

        // expectedJsonValue

        << rootMap.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << arrayOfMapsJson

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << false                          << false

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue: empty QJsonObject => map-of-maps

    rootMap.fromJsonValue(QJsonValue(QJsonObject()));

    QTest::newRow("Set empty QJsonObject via ::fromJsonValue() => map-of-maps")

        // rootMap                        // expectedJson

        << rootMap                        << QString("{}"_L1)

        // expectedJsonValue

        << rootMap.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << true                           << true

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue: empty QJsonArray => array-of-maps

    rootMap.fromJsonValue(QJsonValue(QJsonArray()));

    QTest::newRow("Set empty QJsonArray via ::fromJsonValue() => array-of-maps")

        // rootMap                        // expectedJson

        << rootMap                        << QString("[]"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonArray())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << false                          << false

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // Implicit construction from QMap<QString, QMap<QString, qint32>>

    SchemasModelsOneOf::RootMap rootFromMap(mapOfMaps);

    QTest::newRow("Implicitly construct RootMap from map-of-maps")

        // rootFromMap                    // expectedJson

        << rootFromMap                    << mapOfMapsJson

        // expectedJsonValue

        << rootFromMap.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << mapOfMapsJson                  << QString("[]"_L1)

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << true                           << true

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Implicit construction from QList<QMap<QString, qint32>>

    SchemasModelsOneOf::RootMap rootFromList(arrayOfMaps);

    QTest::newRow("Implicitly construct RootMap from array-of-maps")

        // rootFromList                   // expectedJson

        << rootFromList                   << arrayOfMapsJson

        // expectedJsonValue

        << rootFromList.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << arrayOfMapsJson

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << false                          << false

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // Override map-of-maps with array-of-maps via setter

    rootMap.setOneOfQMapQStringQMapQStringqint32(mapOfMaps);

    rootMap.setOneOfQListQMapQStringqint32(arrayOfMaps);

    QTest::newRow("Override map-of-maps with array-of-maps via setter")

        // rootMap                        // expectedJson

        << rootMap                        << arrayOfMapsJson

        // expectedJsonValue

        << rootMap.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << arrayOfMapsJson

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << false                          << false

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // Override array-of-maps with map-of-maps via setter

    rootMap.setOneOfQListQMapQStringqint32(arrayOfMaps);

    rootMap.setOneOfQMapQStringQMapQStringqint32(mapOfMaps);

    QTest::newRow("Override array-of-maps with map-of-maps via setter")

        // rootMap                        // expectedJson

        << rootMap                        << mapOfMapsJson

        // expectedJsonValue

        << rootMap.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << mapOfMapsJson                  << QString("[]"_L1)

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << true                           << true

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson: map-of-maps with negative values

    const QString negMapJson("{\"neg\":{\"val\":-5}}"_L1);

    rootMap.fromJson(negMapJson);

    QTest::newRow("Set map-of-maps with negative values via ::fromJson()")

        // rootMap                        // expectedJson

        << rootMap                        << negMapJson

        // expectedJsonValue

        << rootMap.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << negMapJson                     << QString("[]"_L1)

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << true                           << true

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson: array-of-maps with empty inner maps

    const QString emptyInnerJson("[{},{}]"_L1);

    rootMap.fromJson(emptyInnerJson);

    QTest::newRow("Set array-of-maps with empty inner maps via ::fromJson()")

        // rootMap                        // expectedJson

        << rootMap                        << emptyInnerJson

        // expectedJsonValue

        << rootMap.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << emptyInnerJson

        // isOneOfMapOfMapsValid          // isOneOfMapOfMapsSet

        << false                          << false

        // isOneOfArrayOfMapsValid        // isOneOfArrayOfMapsSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

void OneOfTest::testRootMapJsonConversionMethods()

    QFETCH(SchemasModelsOneOf::RootMap, rootMap);

    QFETCH(QString, expectedJson);

    QFETCH(QJsonValue, expectedJsonValue);

    QFETCH(QString, oneOf0ExpectedJson);

    QFETCH(QString, oneOf1ExpectedJson);

    QFETCH(bool, isOneOfMapOfMapsValid);

    QFETCH(bool, isOneOfMapOfMapsSet);

    QFETCH(bool, isOneOfArrayOfMapsValid);

    QFETCH(bool, isOneOfArrayOfMapsSet);

    QFETCH(bool, isValid);

    QFETCH(bool, isSet);

    QCOMPARE(rootMap.asJson(), expectedJson);

    QCOMPARE(rootMap.asJsonValue(), expectedJsonValue);

    QCOMPARE(mapMapInt32AsJson(rootMap.getOneOfQMapQStringQMapQStringqint32()),

             oneOf0ExpectedJson);

    QCOMPARE(rootMap.isOneOfQMapQStringQMapQStringqint32Valid(),

             isOneOfMapOfMapsValid);

    QCOMPARE(rootMap.isOneOfQMapQStringQMapQStringqint32Set(),

             isOneOfMapOfMapsSet);

    QCOMPARE(listMapInt32AsJson(rootMap.getOneOfQListQMapQStringqint32()),

             oneOf1ExpectedJson);

    QCOMPARE(rootMap.isOneOfQListQMapQStringqint32Valid(),

             isOneOfArrayOfMapsValid);

    QCOMPARE(rootMap.isOneOfQListQMapQStringqint32Set(),

             isOneOfArrayOfMapsSet);

    QCOMPARE(rootMap.isValid(), isValid);

    QCOMPARE(rootMap.isSet(), isSet);

// Helper: serialize QMap<QString, Dog> to compact JSON string

static QString mapDogAsJson(const QMap<QString, SchemasModelsOneOf::Dog> &v)

    QJsonObject outer;

    for (const auto &[key, dog] : v.asKeyValueRange())

        outer.insert(key, dog.asJsonValue());

    return QString::fromUtf8(QJsonDocument(outer).toJson(QJsonDocument::Compact));

// Helper: serialize QList<QMap<QString, Duck>> to compact JSON string

static QString listMapDuckAsJson(const QList<QMap<QString, SchemasModelsOneOf::Duck>> &v)

    QJsonArray arr;

    for (const auto &map : v) {

        QJsonObject obj;

        for (const auto &[key, duck] : map.asKeyValueRange())

            obj.insert(key, duck.asJsonValue());

        arr.append(obj);

    return QString::fromUtf8(QJsonDocument(arr).toJson(QJsonDocument::Compact));

void OneOfTest::testRootMapModelsJsonConversionMethods_data()

    QTest::addColumn<SchemasModelsOneOf::RootMapModels>("rootMapModels");

    QTest::addColumn<QString>("expectedJson");

    QTest::addColumn<QJsonValue>("expectedJsonValue");

    QTest::addColumn<QString>("oneOf0ExpectedJson");

    QTest::addColumn<QString>("oneOf1ExpectedJson");

    QTest::addColumn<bool>("isOneOfMapOfDogsValid");

    QTest::addColumn<bool>("isOneOfMapOfDogsSet");

    QTest::addColumn<bool>("isOneOfArrayOfMapDucksValid");

    QTest::addColumn<bool>("isOneOfArrayOfMapDucksSet");

    QTest::addColumn<bool>("isValid");

    QTest::addColumn<bool>("isSet");

    // RootMapModels has two oneOf alternatives:

    // oneOf0: QMap<QString, Dog>         - map of Dog models

    // oneOf1: QList<QMap<QString, Duck>> - array of maps of Duck models

    SchemasModelsOneOf::RootMapModels rootMapModels;

    QTest::newRow("Empty RootMapModels object")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << false                          << false

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // Set a valid map-of-Dogs via setter

    SchemasModelsOneOf::Dog dog1;

    dog1.setBark(true);

    dog1.setBreed("Husky"_L1);

    SchemasModelsOneOf::Dog dog2;

    dog2.setBark(false);

    dog2.setBreed("Dingo"_L1);

    QMap<QString, SchemasModelsOneOf::Dog> mapOfDogs;

    mapOfDogs.insert("rex"_L1, dog1);

    mapOfDogs.insert("fido"_L1, dog2);

    rootMapModels.setOneOfQMapQStringDog(mapOfDogs);

    const QString mapOfDogsJson = mapDogAsJson(mapOfDogs);

    QTest::newRow("Set valid map-of-Dogs via setter")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << mapOfDogsJson

        // expectedJsonValue

        << rootMapModels.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << mapOfDogsJson                  << QString("[]"_L1)

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << true                           << true

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set an empty map-of-Dogs via setter (empty map is still valid)

    const QMap<QString, SchemasModelsOneOf::Dog> emptyMapOfDogs;

    rootMapModels.setOneOfQMapQStringDog(emptyMapOfDogs);

    QTest::newRow("Set empty map-of-Dogs via setter")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << QString("{}"_L1)

        // expectedJsonValue

        << rootMapModels.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << true                           << true

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set a valid array-of-maps-of-Ducks via setter

    SchemasModelsOneOf::Duck duck1;

    duck1.setHunts(true);

    duck1.setAge(3);

    SchemasModelsOneOf::Duck duck2;

    duck2.setHunts(false);

    duck2.setAge(5);

    QList<QMap<QString, SchemasModelsOneOf::Duck>> arrayOfMapDucks;

    arrayOfMapDucks.append({{"donald"_L1, duck1}, {"daisy"_L1, duck2}});

    arrayOfMapDucks.append({{"scrooge"_L1, duck1}});

    rootMapModels.setOneOfQListQMapQStringDuck(arrayOfMapDucks);

    const QString arrayOfMapDucksJson = listMapDuckAsJson(arrayOfMapDucks);

    QTest::newRow("Set valid array-of-map-Ducks via setter")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << arrayOfMapDucksJson

        // expectedJsonValue

        << rootMapModels.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << arrayOfMapDucksJson

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << false                          << false

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // Set an empty array-of-maps-of-Ducks via setter (empty list is still valid)

    const QList<QMap<QString, SchemasModelsOneOf::Duck>> emptyArrayOfMapDucks;

    rootMapModels.setOneOfQListQMapQStringDuck(emptyArrayOfMapDucks);

    QTest::newRow("Set empty array-of-map-Ducks via setter")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << QString("[]"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonArray())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << false                          << false

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // Set single-entry map-of-Dogs via setter

    QMap<QString, SchemasModelsOneOf::Dog> singleMapOfDogs;

    singleMapOfDogs.insert("buddy"_L1, dog1);

    rootMapModels.setOneOfQMapQStringDog(singleMapOfDogs);

    const QString singleMapOfDogsJson = mapDogAsJson(singleMapOfDogs);

    QTest::newRow("Set single-entry map-of-Dogs via setter")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << singleMapOfDogsJson

        // expectedJsonValue

        << rootMapModels.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << singleMapOfDogsJson            << QString("[]"_L1)

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << true                           << true

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Set single-entry array-of-maps-of-Ducks via setter

    QList<QMap<QString, SchemasModelsOneOf::Duck>> singleArrayOfMapDucks;

    singleArrayOfMapDucks.append({{"quack"_L1, duck2}});

    rootMapModels.setOneOfQListQMapQStringDuck(singleArrayOfMapDucks);

    const QString singleArrayOfMapDucksJson = listMapDuckAsJson(singleArrayOfMapDucks);

    QTest::newRow("Set single-entry array-of-map-Ducks via setter")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << singleArrayOfMapDucksJson

        // expectedJsonValue

        << rootMapModels.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << singleArrayOfMapDucksJson

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << false                          << false

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // fromJson: valid map-of-Dogs JSON

    rootMapModels.fromJson(mapOfDogsJson);

    QTest::newRow("Set valid map-of-Dogs via ::fromJson()")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << mapOfDogsJson

        // expectedJsonValue

        << rootMapModels.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << mapOfDogsJson                  << QString("[]"_L1)

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << true                           << true

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson: valid array-of-maps-of-Ducks JSON

    rootMapModels.fromJson(arrayOfMapDucksJson);

    QTest::newRow("Set valid array-of-map-Ducks via ::fromJson()")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << arrayOfMapDucksJson

        // expectedJsonValue

        << rootMapModels.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << arrayOfMapDucksJson

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << false                          << false

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // fromJson: empty object {}

    rootMapModels.fromJson("{}"_L1);

    QTest::newRow("Set empty object {} via ::fromJson()")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << QString("{}"_L1)

        // expectedJsonValue

        << rootMapModels.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << true                           << true

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson: empty array [] => array-of-maps-of-Ducks

    rootMapModels.fromJson("[]"_L1);

    QTest::newRow("Set empty array [] via ::fromJson() => empty array-of-map-Ducks")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << QString("[]"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonArray())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << false                          << false

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // fromJson: array of ints [1,2,3] => each element is int, not a map

    rootMapModels.fromJson("[1,2,3]"_L1);

    QTest::newRow("Set [1,2,3] via ::fromJson() => fails array-of-map-Ducks")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << false                          << false

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // fromJson: integer value => no integer alternative => reset

    rootMapModels.fromJson("42"_L1);

    QTest::newRow("Set integer via ::fromJson() => no integer alternative")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << false                          << false

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // fromJson: bool value => no bool alternative => reset

    rootMapModels.fromJson("true"_L1);

    QTest::newRow("Set bool 'true' via ::fromJson() => no bool alternative")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << false                          << false

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // fromJson: string value => no string alternative => reset

    rootMapModels.fromJson("\"hello\""_L1);

    QTest::newRow("Set string via ::fromJson() => no string alternative")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << false                          << false

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // fromJson: invalid JSON => reset

    rootMapModels.fromJson("{invalid json}"_L1);

    QTest::newRow("Set invalid JSON via ::fromJson() => reset")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << false                          << false

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // fromJson: null => reset

    rootMapModels.fromJson("null"_L1);

    QTest::newRow("Set null via ::fromJson() => reset")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << QString("{}"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonObject())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << false                          << false

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << false                          << false

        // isValid                        // isSet

        << false                          << false;

    // fromJsonValue: valid map-of-Dogs object

    rootMapModels.fromJsonValue(QJsonValue::fromJson(mapOfDogsJson.toUtf8()));

    QTest::newRow("Set valid map-of-Dogs via ::fromJsonValue()")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << mapOfDogsJson

        // expectedJsonValue

        << rootMapModels.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << mapOfDogsJson                  << QString("[]"_L1)

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << true                           << true

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue: valid array-of-maps-of-Ducks

    rootMapModels.fromJsonValue(QJsonValue::fromJson(arrayOfMapDucksJson.toUtf8()));

    // !!! ERROR: map-of-Dogs valid/set flags are not reset when array-of-Ducks wins

    QTest::newRow("Set valid array-of-map-Ducks via ::fromJsonValue()")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << arrayOfMapDucksJson

        // expectedJsonValue

        << rootMapModels.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << arrayOfMapDucksJson

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << false                          << false

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue: empty QJsonObject => map-of-Dogs wins

    rootMapModels.fromJsonValue(QJsonValue(QJsonObject()));

    QTest::newRow("Set empty QJsonObject via ::fromJsonValue()")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << QString("{}"_L1)

        // expectedJsonValue

        << rootMapModels.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << true                           << true

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJsonValue: empty QJsonArray => array-of-maps-of-Ducks

    rootMapModels.fromJsonValue(QJsonValue(QJsonArray()));

    QTest::newRow("Set empty QJsonArray via ::fromJsonValue() => array-of-map-Ducks")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << QString("[]"_L1)

        // expectedJsonValue

        << QJsonValue(QJsonArray())

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << QString("[]"_L1)

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << false                          << false

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // Implicit construction from QMap<QString, Dog>

    SchemasModelsOneOf::RootMapModels rootFromMap(mapOfDogs);

    QTest::newRow("Implicitly construct RootMapModels from map-of-Dogs")

        // rootFromMap                    // expectedJson

        << rootFromMap                    << mapOfDogsJson

        // expectedJsonValue

        << rootFromMap.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << mapOfDogsJson                  << QString("[]"_L1)

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << true                           << true

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // Implicit construction from QList<QMap<QString, Duck>>

    SchemasModelsOneOf::RootMapModels rootFromList(arrayOfMapDucks);

    QTest::newRow("Implicitly construct RootMapModels from array-of-map-Ducks")

        // rootFromList                   // expectedJson

        << rootFromList                   << arrayOfMapDucksJson

        // expectedJsonValue

        << rootFromList.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << arrayOfMapDucksJson

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << false                          << false

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // Override map-of-Dogs with array-of-maps-of-Ducks via setter

    rootMapModels.setOneOfQMapQStringDog(mapOfDogs);

    rootMapModels.setOneOfQListQMapQStringDuck(arrayOfMapDucks);

    QTest::newRow("Override map-of-Dogs with array-of-map-Ducks via setter")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << arrayOfMapDucksJson

        // expectedJsonValue

        << rootMapModels.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << arrayOfMapDucksJson

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << false                          << false

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

    // Override array-of-maps-of-Ducks with map-of-Dogs via setter

    rootMapModels.setOneOfQListQMapQStringDuck(arrayOfMapDucks);

    rootMapModels.setOneOfQMapQStringDog(mapOfDogs);

    QTest::newRow("Override array-of-map-Ducks with map-of-Dogs via setter")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << mapOfDogsJson

        // expectedJsonValue

        << rootMapModels.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << mapOfDogsJson                  << QString("[]"_L1)

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << true                           << true

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson: map with Dog that has only required field (bark)

    const QString minimalDogMapJson("{\"spot\":{\"bark\":true}}"_L1);

    rootMapModels.fromJson(minimalDogMapJson);

    QTest::newRow("Set map-of-Dogs with minimal Dog (bark only) via ::fromJson()")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << minimalDogMapJson

        // expectedJsonValue

        << rootMapModels.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << minimalDogMapJson              << QString("[]"_L1)

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << true                           << true

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << false                          << false

        // isValid                        // isSet

        << true                           << true;

    // fromJson: array with maps of Ducks with empty inner maps

    const QString emptyInnerDucksJson("[{},{}]"_L1);

    rootMapModels.fromJson(emptyInnerDucksJson);

    QTest::newRow("Set array-of-map-Ducks with empty inner maps via ::fromJson()")

        // rootMapModels                  // expectedJson

        << rootMapModels                  << emptyInnerDucksJson

        // expectedJsonValue

        << rootMapModels.asJsonValue()

        // oneOf0ExpectedJson             // oneOf1ExpectedJson

        << QString("{}"_L1)               << emptyInnerDucksJson

        // isOneOfMapOfDogsValid          // isOneOfMapOfDogsSet

        << false                          << false

        // isOneOfArrayOfMapDucksValid    // isOneOfArrayOfMapDucksSet

        << true                           << true

        // isValid                        // isSet

        << true                           << true;

void OneOfTest::testRootMapModelsJsonConversionMethods()

    QFETCH(SchemasModelsOneOf::RootMapModels, rootMapModels);

    QFETCH(QString, expectedJson);

    QFETCH(QJsonValue, expectedJsonValue);

    QFETCH(QString, oneOf0ExpectedJson);

    QFETCH(QString, oneOf1ExpectedJson);

    QFETCH(bool, isOneOfMapOfDogsValid);

    QFETCH(bool, isOneOfMapOfDogsSet);

    QFETCH(bool, isOneOfArrayOfMapDucksValid);

    QFETCH(bool, isOneOfArrayOfMapDucksSet);

    QFETCH(bool, isValid);

    QFETCH(bool, isSet);

    QCOMPARE(rootMapModels.asJson(), expectedJson);

    QCOMPARE(rootMapModels.asJsonValue(), expectedJsonValue);

    QCOMPARE(mapDogAsJson(rootMapModels.getOneOfQMapQStringDog()),

             oneOf0ExpectedJson);

    QCOMPARE(rootMapModels.isOneOfQMapQStringDogValid(),

             isOneOfMapOfDogsValid);

    QCOMPARE(rootMapModels.isOneOfQMapQStringDogSet(),

             isOneOfMapOfDogsSet);

    QCOMPARE(listMapDuckAsJson(rootMapModels.getOneOfQListQMapQStringDuck()),

             oneOf1ExpectedJson);

    QCOMPARE(rootMapModels.isOneOfQListQMapQStringDuckValid(),

             isOneOfArrayOfMapDucksValid);

    QCOMPARE(rootMapModels.isOneOfQListQMapQStringDuckSet(),

             isOneOfArrayOfMapDucksSet);

    QCOMPARE(rootMapModels.isValid(), isValid);

    QCOMPARE(rootMapModels.isSet(), isSet);

QTEST_MAIN(OneOfTest)

#include "tst_oneof.moc"

Revision control

Copy as Markdown