Mercurial > qtargs
view src/UNIT_TESTS/qargsut.hpp @ 0:04ad7227e290
Rebuilding structure for development.
| author | John Schneiderman <JohnMS@CodeGNU.com> |
|---|---|
| date | Sat, 14 Jun 2014 13:17:37 +0000 |
| parents | |
| children | 2e08e35922c9 |
line wrap: on
line source
/******************************************************************************* *** This file is part of QtArgs. *** *** *** *** Copyright (C) 2011, 2012, 2014 *** *** CodeGNU Solutions <Licensing _AT_ CodeGNU _DOT_ com> *** *** *** *** This program is free software: you can redistribute it and/or modify *** *** it under the terms of the GNU Lesser General Public License as *** *** published by the Free Software Foundation, either version 3 of the *** *** License, or (at your option) any later version. *** *** *** *** This program is distributed in the hope that it will be useful, but *** *** WITHOUT ANY WARRANTY; without even the implied warranty of *** *** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. *** *** See the GNU Lesser General Public License for more details. *** *** *** *** You should have received a copy of the GNU Lesser General Public *** *** License along with this program. If not, see *** *** <http://www.gnu.org/licenses/>. *** *******************************************************************************/ #ifndef QARGSUT_HPP_ #define QARGSUT_HPP_ #include "qargs.h" #include <QTest> #include <QObject> #include <QMap> #include <QString> #include <QStringList> #include <QByteArray> #include <QDebug> #include <QSignalSpy> #include <QList> #include <QVariant> #include <stdexcept> using std::domain_error; using std::runtime_error; using std::logic_error; /** * QArgs Unit Test * * Full unit test for all the components of QArgs. Each member function is * tested for handling both valid and invalid data. Those member functions * that fire signals are verified as well. Any exceptions thrown by a member * function is verified for both throwing and not throwing the specified * exception. */ class QArgsUT: public QObject { Q_OBJECT /// Assumed operating system marker, '?' in Windows and 'h' in Unix. const QChar MARKER; /// Argument value used for testing short name options. const char* const shortValueTest; /// Number of arguments tested static const int ARGC = 8; /// Container to represent the arguments from an user. const char* argv[ARGC]; /// First argument as the application running. const char* const arg0; /// Short-name argument test option. const char* const arg1; /// Value for the short-named argument. const char* const arg2; /// Long-name argument test option and the value in Unix. const char* const arg3; /// Long-name argument value in Windows. const char* const arg4; /// Short-name help option test const char* const arg5; /// Long-name help option test const char* const arg6; /// Flag option test const char* const arg7; public: /// Default construct for testing QArgsUT(): QObject(NULL), #ifdef Q_OS_WIN32 MARKER('/'), shortValueTest("/v"), arg0("C:\\QtMGW\\QtArgs\\qargsut.exe"), // Not a valid argument arg1("/i"), // First half of a short named argument arg2("5"), // value for the short named argument arg3("/double"), // Whole argument arg4("25.25"), // Whole argument value arg5("/?"), // short help arg6("/help"), // long help arg7("/f") // Flag argument #else MARKER('-'), shortValueTest("-v"), arg0("/usr/bin/qargsut"), // Not a valid argument arg1("-i"), // First half of a short named argument arg2("5"), // value for the short named argument arg3("--double=25.25"), // Whole argument arg4(""), // Unix whole values are together arg5("-h"), // short help arg6("--help"), // long help arg7("-f") // Flag argument #endif { qDebug() << "Detected OS marker:" << MARKER; argv[0] = arg0; argv[1] = arg1; argv[2] = arg2; argv[3] = arg3; argv[4] = arg4; argv[5] = arg5; argv[6] = arg6; argv[7] = arg7; } private slots: #ifndef QT_NO_DEBUG_OUTPUT /// Test argument constructor void constructor() { QArgs args(ARGC, argv); QVERIFY(args.mArguments.count() == ARGC); QVERIFY(args.mArguments[0] == arg0); QVERIFY(args.mArguments[1] == arg1); QVERIFY(args.mArguments[2] == arg2); QVERIFY(args.mArguments[3] == arg3); QVERIFY(args.mArguments[4] == arg4); QVERIFY(args.mArguments[5] == arg5); QVERIFY(args.mArguments[6] == arg6); QVERIFY(args.mArguments[7] == arg7); // Verify help is established QVERIFY(args.mSupported.value(QArgs::SHORT_HELP).shortName == QArgs::SHORT_HELP); QVERIFY(args.mSupported.value(QArgs::SHORT_HELP).longName == "help"); QVERIFY(args.mSupported.value( QArgs::SHORT_HELP).description.isEmpty()); QVERIFY(args.mSupported.value(QArgs::SHORT_HELP).needsValue == false); QVERIFY(args.mSupported.value(QArgs::SHORT_HELP).required == false); QVERIFY(args.mIsCaseSensative == true); QVERIFY(args.mIsLocked == false); } /// Test adding argument support void addSupported() { QArgs args(ARGC, argv); // Test normal support usage args.addSupported('i', "integer", "Whole number test", true, true); args.addSupported('d', "double", "Real number test", true); args.addSupported('f', "flag", "Flag test"); QVERIFY(args.mSupported.value('i').shortName == 'i'); QVERIFY(args.mSupported.value('i').longName == "integer"); QVERIFY(args.mSupported.value('i').description == "Whole number test"); QVERIFY(args.mSupported.value('i').needsValue == true); QVERIFY(args.mSupported.value('i').required == true); QVERIFY(args.mSupported.value('d').shortName == 'd'); QVERIFY(args.mSupported.value('d').longName == "double"); QVERIFY(args.mSupported.value('d').description == "Real number test"); QVERIFY(args.mSupported.value('d').needsValue == true); QVERIFY(args.mSupported.value('d').required == false); QVERIFY(args.mSupported.value('f').shortName == 'f'); QVERIFY(args.mSupported.value('f').longName == "flag"); QVERIFY(args.mSupported.value('f').description == "Flag test"); QVERIFY(args.mSupported.value('f').needsValue == false); QVERIFY(args.mSupported.value('f').required == false); // Test exception cases try { args.addSupported('h', "question", "Short help test"); QVERIFY2(false, "Short help argument not caught"); } catch (domain_error& error) { qDebug() << error.what(); } try { args.addSupported('?', "win-question", "Short help for Windows test"); QVERIFY2(false, "Short help argument for Windows not caught"); } catch (domain_error& error) { qDebug() << error.what(); } try { args.addSupported('p', "help", "Long help test"); QVERIFY2(false, "Long help argument not caught"); } catch (domain_error& error) { qDebug() << error.what(); } try { args.addSupported(' ', "aaaa", "Empty argument short test"); QVERIFY2(false, "Empty short argument not caught"); } catch (logic_error& error) { qDebug() << error.what(); } try { args.addSupported('e', " ", "Empty argument long test"); QVERIFY2(false, "Empty long argument not caught"); } catch (logic_error& error) { qDebug() << error.what(); } try { args.addSupported('r', "required", "Required test", false, true); QVERIFY2(false, "Required not caught"); } catch (runtime_error& error) { qDebug() << error.what(); } try { args.addSupported('a', "longA1", "First in repeated short option " "name test"); args.addSupported('a', "longA2", "The repeated short option " "name test"); QVERIFY2(false, "Repeated short option name not caught"); } catch (logic_error& error) { qDebug() << error.what(); } try { args.addSupported('b', "longB", "First in repeated long option " "name test"); args.addSupported('c', "longB", "The repeated long option " "name test"); QVERIFY2(false, "Repeated long option name not caught"); } catch (logic_error& error) { qDebug() << error.what(); } } /// Test verification of supported arguments void verifySupport() { try { QArgs args(ARGC, argv); args.addSupported('i', "integer", "Whole number test", true, true); args.addSupported('d', "double", "Real number test", true); args.addSupported('f', "flag", "Flag test"); args.verifySupport(); QVERIFY(true); } catch(runtime_error& error) { qDebug() << error.what(); QVERIFY2(false, "Short & long arguments provided, and are " "listed as supported"); } try { QArgs args(ARGC, argv); args.verifySupport(); QVERIFY2(false, "Short & long arguments not provided, but none " "listed as supported"); } catch(logic_error& error) { qDebug() << error.what(); } try { QArgs args(ARGC, argv); args.addSupported('i', "integer", "Whole number test", true, true); args.addSupported('d', "double", "Real number test", true); args.verifySupport(); QVERIFY2(false, "Short & long arguments provided, but some are " "not listed as supported"); } catch(runtime_error& error) { qDebug() << error.what(); } } // Test argument list lock void argumentListLock() { try { QArgs args(ARGC, argv); QVERIFY2(false == args.mIsLocked, "Arguments list not " "locked test."); args.lock(); QVERIFY2(true == args.mIsLocked, "Arguments list locked test."); args.addSupported('a', "longA", "Test argument adding after lock."); QVERIFY2(false, "Test argument adding after lock failed."); } catch(logic_error& error) { qDebug() << error.what(); } } /// Test index of a short name argument void shortNameIndex() { QArgs args(ARGC, argv); args.addSupported('i', "integer", "Whole number test", true, true); args.addSupported('d', "double", "Real number test", true); args.addSupported('f', "flag", "Flag test"); QVERIFY(args.shortNameIndex('i') == 1); QVERIFY(args.shortNameIndex('d') == -1); #ifdef Q_OS_WIN32 QVERIFY(args.shortNameIndex('?') == 5); QVERIFY(args.shortNameIndex('h') == -1); #else QVERIFY(args.shortNameIndex('h') == 5); QVERIFY(args.shortNameIndex('?') == -1); #endif QVERIFY(args.shortNameIndex('f') == 7); QVERIFY(args.shortNameIndex('a') == -1); } /// Test index of a long name argument void longNameIndex() { { QArgs args(ARGC, argv); args.addSupported('i', "integer", "Whole number test", true, true); args.addSupported('d', "double", "Real number test", true); args.addSupported('f', "flag", "Flag test"); QVERIFY(args.longNameIndex('i') == -1); QVERIFY(args.longNameIndex('d') == 3); #ifdef Q_OS_WIN32 QVERIFY(args.longNameIndex('?') == 6); QVERIFY(args.longNameIndex('h') == -1); #else QVERIFY(args.longNameIndex('h') == 6); QVERIFY(args.longNameIndex('?') == -1); #endif QVERIFY(args.longNameIndex('f') == -1); QVERIFY(args.longNameIndex('a') == -1); } { QArgs args(ARGC, argv); // Arguments not listed QVERIFY(args.longNameIndex('i') == -1); QVERIFY(args.longNameIndex('d') == -1); #ifdef Q_OS_WIN32 QVERIFY(args.longNameIndex('?') == 6); #else QVERIFY(args.longNameIndex('h') == 6); #endif QVERIFY(args.longNameIndex('f') == -1); } } #endif /// Test arguments accessor void arguments() { QArgs args(ARGC, argv); QStringList argsTest(args.arguments()); QVERIFY(argsTest.count() == ARGC); QVERIFY(argsTest[0] == arg0); QVERIFY(argsTest[1] == arg1); QVERIFY(argsTest[2] == arg2); QVERIFY(argsTest[3] == arg3); QVERIFY(argsTest[4] == arg4); QVERIFY(argsTest[5] == arg5); QVERIFY(argsTest[6] == arg6); QVERIFY(argsTest[7] == arg7); } /// Test marker accessor void marker() { QArgs args(ARGC, argv); QVERIFY(args.marker() == MARKER); } /// Test count void count() { { // Only application name test #ifdef Q_OS_WIN32 const char* argvValue[1] = { "C:\bin\bash" }; #else const char* argvValue[1] = { "/bin/sh" }; #endif QArgs args(1, argvValue); QVERIFY(args.count() == 0); } { // No Argument test #ifdef Q_OS_WIN32 const char* argvValue[3] = { "C:\bin\bash", "v", "dfd" }; #else const char* argvValue[3] = { "/bin/sh", "v", "dfd" }; #endif QArgs args(3, argvValue); QVERIFY(args.count() == 0); } { QArgs args(ARGC, argv); // Valid arguments that are counted: -i, --double, -h, --help, -f QVERIFY(args.count() == 5); } } /// Test automated help test support void hasHelp() { { const char* help[1] = { arg5 }; QArgs args(1, help); QVERIFY(args.hasHelp() == true); } { const char* help[1] = { arg6 }; QArgs args(1, help); QVERIFY(args.hasHelp() == true); } { const char* help[1] = { arg1 }; // no help QArgs args(1, help); QVERIFY(args.hasHelp() == false); } } /// Test automated display help /// @todo verify the standard output buffer contains the same text as /// the signal fired. void showHelp() { QArgs args(ARGC, argv); QSignalSpy help(&args, SIGNAL(help(const QString&))); args.addSupported('i', "integer", "Whole number test", true, true); args.addSupported('d', "double", "Real number test", true); args.addSupported('f', "flag", "Flag test"); QVERIFY(help.isValid()); args.showHelp(); QVERIFY(help.count() == 1); QList< QVariant > arguments(help.takeAt(0)); QString text(arguments.at(0).toString()); #ifdef Q_OS_WIN32 # ifdef QT_NO_DEBUG_OUTPUT QVERIFY(text.startsWith("usage: qtargsut.exe [options]")); # else QVERIFY(text.startsWith("usage: qtargsutd.exe [options]")); # endif QVERIFY(text.contains("Options:")); QVERIFY(text.contains(" /d <value>")); QVERIFY(text.contains("Real number test")); QVERIFY(text.contains(" /f")); QVERIFY(text.contains("Flag test")); QVERIFY(text.contains(" /i <value>")); QVERIFY(text.contains("Whole number test")); #else # ifdef QT_NO_DEBUG_OUTPUT QVERIFY(text.startsWith("usage: qtargsut [options]")); # else QVERIFY(text.startsWith("usage: qtargsutd [options]")); # endif QVERIFY(text.contains("Options:")); QVERIFY(text.contains(" -d <value>")); QVERIFY(text.contains("Real number test")); QVERIFY(text.contains(" -f")); QVERIFY(text.contains("Flag test")); QVERIFY(text.contains(" -i <value>")); QVERIFY(text.contains("Whole number test")); #endif } /// Test display about /// @todo verify the standard output buffer contains the same text as /// the signal fired. void showAbout() { QArgs args(ARGC, argv); QSignalSpy about(&args, SIGNAL(about(const QString&))); QVERIFY(about.isValid()); args.about(); QVERIFY(about.count() == 1); QList< QVariant > arguments(about.takeAt(0)); QVERIFY(arguments.at(0).toString() == QString( "QtArgs version 1.3.0\n" "Copyright (C) 2011 - 2014 John Schneiderman\n" "QtArgs comes with ABSOLUTELY NO WARRANTY.\nThis is " "free software, and you are welcome to redistribute it\n" "under certain conditions; see the LICENSE file for details,\n" "or the Free Software Foundation's LGPL.\n")); } /// Test has argument void hasArgument() { { QArgs args(ARGC, argv); QVERIFY(args.hasArgument('f') == true); } { QArgs args(ARGC, argv); QVERIFY(args.hasArgument('p') == false); } } // Test multiple values void values() { { const char* argvValue[5] = { shortValueTest, "1", "2", "3", "4" }; QArgs args(5, argvValue); args.addSupported('v', "values", "Multiple values short test.", true); try { QList< qint32 > values(args.values('v', 15)); QVERIFY(4 == values.size()); QVERIFY(1 == values.at(0)); QVERIFY(2 == values.at(1)); QVERIFY(3 == values.at(2)); QVERIFY(4 == values.at(3)); } catch (runtime_error& error) { QVERIFY2(false, error.what()); } } { const char* argvValue[5] = { shortValueTest, "1", "2", "a", "4" }; QArgs args(5, argvValue); args.addSupported('v', "values", "Multiple values short test, " "with a bad value.", true); try { QList< qint32 > values(args.values('v', 15)); QVERIFY(3 == values.size()); QVERIFY(1 == values.at(0)); QVERIFY(2 == values.at(1)); QVERIFY(4 == values.at(2)); } catch (runtime_error& error) { QVERIFY2(false, error.what()); } } { const char* argvValue[9] = { #ifdef Q_OS_WIN32 "/a", #else "-a", #endif "p", shortValueTest, "1", "2", "3", "4", #ifdef Q_OS_WIN32 "/b", #else "-b", #endif "5", }; QArgs args(9, argvValue); args.addSupported('v', "values", "Multiple values short test " "with extra options.", true); args.addSupported('a', "aValue", "Leader value", true); args.addSupported('b', "bValue", "Follower value", true); try { QList< qint32 > values(args.values('v', 15)); QVERIFY(4 == values.size()); QVERIFY(1 == values.at(0)); QVERIFY(2 == values.at(1)); QVERIFY(3 == values.at(2)); QVERIFY(4 == values.at(3)); } catch (runtime_error& error) { QVERIFY2(false, error.what()); } } { const char* argvValue[5] = { #ifdef Q_OS_WIN32 "/values", #else "--values", #endif "4", "3", "2", "1" }; QArgs args(5, argvValue); args.addSupported('v', "values", "Multiple values long test ", true); try { QList< qint32 > values(args.values('v', 15)); QVERIFY(4 == values.size()); QVERIFY(4 == values.at(0)); QVERIFY(3 == values.at(1)); QVERIFY(2 == values.at(2)); QVERIFY(1 == values.at(3)); } catch (runtime_error& error) { QVERIFY2(false, error.what()); } } } /// Test value boolean void valueBoolean() { bool value = false; // Short name tests { const char* argvValue[2] = { shortValueTest, "TrUe"}; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,bool))); args.addSupported('v', "value", "Boolean true/false value " "sensative short test", true); QVERIFY(args.value('v', value) == true); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toBool() == true); } { const char* argvValue[2] = { shortValueTest, "TrUe"}; QArgs args(2, argvValue, QArgs::CASE_INSENSATIVE); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,bool))); args.addSupported('V', "value", "Boolean true/false value " "insensative short test", true); QVERIFY(args.value('V', value) == true); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'V'); QVERIFY(arguments.at(1).toBool() == true); } { const char* argvValue[2] = { shortValueTest, "T"}; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,bool))); args.addSupported('v', "value", "Boolean t/f value short test", true); QVERIFY(args.value('v', value, QArgs::T_OR_F) == true); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toBool() == true); } { const char* argvValue[2] = { shortValueTest, "1"}; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,bool))); args.addSupported('v', "value", "Boolean 1/0 value short test", true); QVERIFY(args.value('v', value, QArgs::ONE_OR_ZERO) == true); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toBool() == true); } { const char* argvValue[2] = { shortValueTest, "YeS"}; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,bool))); args.addSupported('v', "value", "Boolean yes/no value short test", true); QVERIFY(args.value('v', value, QArgs::YES_OR_NO) == true); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toBool() == true); } { const char* argvValue[2] = { shortValueTest, "Y"}; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,bool))); args.addSupported('v', "value", "Boolean y/n value short test", true); QVERIFY(args.value('v', value, QArgs::Y_OR_N) == true); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toBool() == true); } { const char* argvValue[2] = { shortValueTest, "On" }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,bool))); args.addSupported('v', "value", "Boolean on/off value short test", true); QVERIFY(args.value('v', value, QArgs::ON_OR_OFF) == true); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toBool() == true); } // Long name tests { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "TrUe" #else "--value=TrUe", "" #endif }; // Test case // insensitivity QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,bool))); args.addSupported('v', "value", "Boolean true/false value " "long test", true); QVERIFY(args.value('v', value) == true); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toBool() == true); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "T" #else "--value=T", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,bool))); args.addSupported('v', "value", "Boolean t/f value long test", true); QVERIFY(args.value('v', value, QArgs::T_OR_F) == true); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toBool() == true); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "1" #else "--value=1", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,bool))); args.addSupported('v', "value", "Boolean 1/0 value long test", true); QVERIFY(args.value('v', value, QArgs::ONE_OR_ZERO) == true); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toBool() == true); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "yes" #else "--value=yes", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,bool))); args.addSupported('v', "value", "Boolean yes/no value long test", true); QVERIFY(args.value('v', value, QArgs::YES_OR_NO) == true); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toBool() == true); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "Y" #else "--value=Y", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,bool))); args.addSupported('v', "value", "Boolean y/n value long test", true); QVERIFY(args.value('v', value, QArgs::Y_OR_N) == true); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toBool() == true); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "ON" #else "--value=On", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,bool))); args.addSupported('v', "value", "Boolean on/off value long test", true); QVERIFY(args.value('v', value, QArgs::ON_OR_OFF) == true); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toBool() == true); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "ON" #else "--value=On", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,bool))); args.addSupported('v', "value", "Boolean on/off and 1/0 value " "combined test", true); QVERIFY(args.value('v', value, static_cast<QArgs::BooleanSupport>( QArgs::ON_OR_OFF | QArgs::ONE_OR_ZERO)) == true); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toBool() == true); } { const char* argvValue[1] = { shortValueTest }; QArgs args(1, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,bool))); args.addSupported('v', "value", "Boolean value short test fail", true); QVERIFY(args.value('v', value) == false); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toBool() == false); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "1.0" #else "--value=1.0", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,bool))); args.addSupported('v', "value", "Boolean value long test " "fail invalid argument", true); QVERIFY(args.value('v', value, QArgs::ONE_OR_ZERO) == false); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toBool() == false); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "dog" #else "--value=DOG", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,bool))); args.addSupported('v', "value", "Boolean value long test " "fail invalid word", true); QVERIFY(args.value('v', value) == false); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toBool() == false); } } /// Test value real numbers void valueReal() { qreal value = 9.630; { const char* argvValue[2] = { shortValueTest, "1.234" }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,qreal))); args.addSupported('v', "value", "Real value short test", true); QVERIFY(qFuzzyCompare(1.0 + args.value('v', value), 1.0 + 1.234)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(qFuzzyCompare(1.0 + arguments.at(1).toDouble(), 1.0 + 1.234)); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "4.321" #else "--value=4.321", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,qreal))); args.addSupported('v', "value", "Real value long test", true); QVERIFY(qFuzzyCompare(1.0 + args.value('v', value), 1.0 + 4.321)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(qFuzzyCompare(1.0 + arguments.at(1).toDouble(), 1.0 + 4.321)); } { const char* argvValue[1] = { shortValueTest }; QArgs args(1, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,qreal))); args.addSupported('v', "value", "Real value short test fail", true); QVERIFY(qFuzzyCompare(1.0 + args.value('v', value), 1.0 + 9.630)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(qFuzzyCompare(1.0 + arguments.at(1).toDouble(), 1.0 + 9.630)); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "Jack" #else "--value=Jack", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,qreal))); args.addSupported('v', "value", "Real value long test fail", true); QVERIFY(qFuzzyCompare(1.0 + args.value('v', value), 1.0 + 9.630)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(qFuzzyCompare(1.0 + arguments.at(1).toDouble(), 1.0 + 9.630)); } } /// Test value 8-bit integer numbers void value8BitIntenger() { qint8 value = -9; { const char* argvValue[2] = { shortValueTest, "-2" }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,qint8))); args.addSupported('v', "value", "8-bit value short test", true); QVERIFY(static_cast<qint8>(args.value('v', value)) == static_cast<qint8>(-2)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<qint8>(arguments.at(1).toLongLong()) == static_cast<qint8>(-2)); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "-4" #else "--value=-4", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,qint8))); args.addSupported('v', "value", "8-bit value long test", true); QVERIFY(static_cast<qint8>(args.value('v', value)) == static_cast<qint8>(-4)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<qint8>(arguments.at(1).toLongLong()) == static_cast<qint8>(-4)); } { const char* argvValue[1] = { shortValueTest }; QArgs args(1, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,qint8))); args.addSupported('v', "value", "8-bit value short test fail", true); QVERIFY(static_cast<qint8>(args.value('v', value)) == static_cast<qint8>(-9)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<qint8>(arguments.at(1).toLongLong()) == static_cast<qint8>(-9)); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "4.45" #else "--value=4.45", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,qint8))); args.addSupported('v', "value", "8-bit value long " "long test fail", true); QVERIFY(static_cast<qint8>(args.value('v', value)) == static_cast<qint8>(-9)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<qint8>(arguments.at(1).toLongLong()) == static_cast<qint8>(-9)); } } /// Test value 16-bit integer numbers void value16BitIntenger() { qint16 value = -9; { const char* argvValue[2] = { shortValueTest, "-2" }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,qint16))); args.addSupported('v', "value", "16-bit value short test", true); QVERIFY(static_cast<qint16>(args.value('v', value)) == static_cast<qint16>(-2)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<qint16>(arguments.at(1).toLongLong()) == static_cast<qint16>(-2)); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "-4" #else "--value=-4", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,qint16))); args.addSupported('v', "value", "16-bit value long test", true); QVERIFY(static_cast<qint16>(args.value('v', value)) == static_cast<qint16>(-4)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<qint16>(arguments.at(1).toLongLong()) == static_cast<qint16>(-4)); } { const char* argvValue[1] = { shortValueTest }; QArgs args(1, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,qint16))); args.addSupported('v', "value", "16-bit value short test fail", true); QVERIFY(static_cast<qint16>(args.value('v', value)) == static_cast<qint16>(-9)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<qint16>(arguments.at(1).toLongLong()) == static_cast<qint16>(-9)); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "4.45" #else "--value=4.45", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,qint16))); args.addSupported('v', "value", "16-bit value long " "long test fail", true); QVERIFY(static_cast<qint16>(args.value('v', value)) == static_cast<qint16>(-9)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<qint16>(arguments.at(1).toLongLong()) == static_cast<qint16>(-9)); } } /// Test value 32-bit integer numbers void value32BitIntenger() { qint32 value = -9; { const char* argvValue[2] = { shortValueTest, "-2" }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,qint32))); args.addSupported('v', "value", "32-bit value short test", true); QVERIFY(static_cast<qint32>(args.value('v', value)) == static_cast<qint32>(-2)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<qint32>(arguments.at(1).toLongLong()) == static_cast<qint32>(-2)); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "-4" #else "--value=-4", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,qint32))); args.addSupported('v', "value", "32-bit value long test", true); QVERIFY(static_cast<qint32>(args.value('v', value)) == static_cast<qint32>(-4)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<qint32>(arguments.at(1).toLongLong()) == static_cast<qint32>(-4)); } { const char* argvValue[1] = { shortValueTest }; QArgs args(1, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,qint32))); args.addSupported('v', "value", "32-bit value short test fail", true); QVERIFY(static_cast<qint32>(args.value('v', value)) == static_cast<qint32>(-9)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<qint32>(arguments.at(1).toLongLong()) == static_cast<qint32>(-9)); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "4.45" #else "--value=4.45", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,qint32))); args.addSupported('v', "value", "32-bit value long " "long test fail", true); QVERIFY(static_cast<qint32>(args.value('v', value)) == static_cast<qint32>(-9)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<qint32>(arguments.at(1).toLongLong()) == static_cast<qint32>(-9)); } } /// Test value 64-bit integer numbers void value64BitIntenger() { qint64 value = -9; { const char* argvValue[2] = { shortValueTest, "-2" }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,qint64))); args.addSupported('v', "value", "64-bit value short test", true); QVERIFY(static_cast<qint64>(args.value('v', value)) == static_cast<qint64>(-2)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<qint64>(arguments.at(1).toLongLong()) == static_cast<qint64>(-2)); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "-4" #else "--value=-4", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,qint64))); args.addSupported('v', "value", "64-bit value long test", true); QVERIFY(static_cast<qint64>(args.value('v', value)) == static_cast<qint64>(-4)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<qint64>(arguments.at(1).toLongLong()) == static_cast<qint64>(-4)); } { const char* argvValue[1] = { shortValueTest }; QArgs args(1, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,qint64))); args.addSupported('v', "value", "64-bit value short test fail", true); QVERIFY(static_cast<qint64>(args.value('v', value)) == static_cast<qint64>(-9)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<qint64>(arguments.at(1).toLongLong()) == static_cast<qint64>(-9)); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "4.45" #else "--value=4.45", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,qint64))); args.addSupported('v', "value", "64-bit value long " "long test fail", true); QVERIFY(static_cast<qint64>(args.value('v', value)) == static_cast<qint64>(-9)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<qint64>(arguments.at(1).toLongLong()) == static_cast<qint64>(-9)); } } /// Test value 8-bit unsigned integer numbers void value8BitUnsignedIntenger() { quint8 value = 9; { const char* argvValue[2] = { shortValueTest, "2" }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,quint8))); args.addSupported('v', "value", "8-bit unsigned value " "short test", true); QVERIFY(static_cast<quint8>(args.value('v', value)) == static_cast<quint8>(2)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<quint8>(arguments.at(1).toULongLong()) == static_cast<quint8>(2)); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "4" #else "--value=4", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,quint8))); args.addSupported('v', "value", "8-bit unsigned value " "long test", true); QVERIFY(static_cast<quint8>(args.value('v', value)) == static_cast<quint8>(4)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<quint8>(arguments.at(1).toULongLong()) == static_cast<quint8>(4)); } { const char* argvValue[1] = { shortValueTest }; QArgs args(1, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,quint8))); args.addSupported('v', "value", "8-bit unsigned value " "short test fail", true); QVERIFY(static_cast<quint8>(args.value('v', value)) == static_cast<quint8>(9)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<quint8>(arguments.at(1).toULongLong()) == static_cast<quint8>(9)); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "4.45" #else "--value=4.45", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,quint8))); args.addSupported('v', "value", "8-bit unsigned value " "long test fail", true); QVERIFY(static_cast<quint8>(args.value('v', value)) == static_cast<quint8>(9)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<quint8>(arguments.at(1).toULongLong()) == static_cast<quint8>(9)); } } /// Test value 16-bit unsigned integer numbers void value16BitUnsignedIntenger() { quint16 value = 9; { const char* argvValue[2] = { shortValueTest, "2" }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,quint16))); args.addSupported('v', "value", "16-bit unsigned value " "short test", true); QVERIFY(static_cast<quint16>(args.value('v', value)) == static_cast<quint16>(2)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<quint16>(arguments.at(1).toULongLong()) == static_cast<quint16>(2)); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "4" #else "--value=4", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,quint16))); args.addSupported('v', "value", "16-bit unsigned value " "long test", true); QVERIFY(static_cast<quint16>(args.value('v', value)) == static_cast<quint16>(4)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<quint16>(arguments.at(1).toULongLong()) == static_cast<quint16>(4)); } { const char* argvValue[1] = { shortValueTest }; QArgs args(1, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,quint16))); args.addSupported('v', "value", "16-bit unsigned value " "short test fail", true); QVERIFY(static_cast<quint16>(args.value('v', value)) == static_cast<quint16>(9)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<quint16>(arguments.at(1).toULongLong()) == static_cast<quint16>(9)); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "4.45" #else "--value=4.45", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,quint16))); args.addSupported('v', "value", "16-bit unsigned value " "long test fail", true); QVERIFY(static_cast<quint16>(args.value('v', value)) == static_cast<quint16>(9)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<quint16>(arguments.at(1).toULongLong()) == static_cast<quint16>(9)); } } /// Test value 32-bit unsigned integer numbers void value32BitUnsignedIntenger() { quint32 value = 9; { const char* argvValue[2] = { shortValueTest, "2" }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,quint32))); args.addSupported('v', "value", "32-bit unsigned value " "short test", true); QVERIFY(static_cast<quint32>(args.value('v', value)) == static_cast<quint32>(2)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<quint32>(arguments.at(1).toULongLong()) == static_cast<quint32>(2)); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "4" #else "--value=4", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,quint32))); args.addSupported('v', "value", "32-bit unsigned value " "long test", true); QVERIFY(static_cast<quint32>(args.value('v', value)) == static_cast<quint32>(4)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<quint32>(arguments.at(1).toULongLong()) == static_cast<quint32>(4)); } { const char* argvValue[1] = { shortValueTest }; QArgs args(1, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,quint32))); args.addSupported('v', "value", "32-bit unsigned value " "short test fail", true); QVERIFY(static_cast<quint32>(args.value('v', value)) == static_cast<quint32>(9)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<quint32>(arguments.at(1).toULongLong()) == static_cast<quint32>(9)); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "4.45" #else "--value=4.45", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,quint32))); args.addSupported('v', "value", "32-bit unsigned value " "long test fail", true); QVERIFY(static_cast<quint32>(args.value('v', value)) == static_cast<quint32>(9)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<quint32>(arguments.at(1).toULongLong()) == static_cast<quint32>(9)); } } /// Test value 64-bit unsigned integer numbers void value64BitUnsignedIntenger() { quint64 value = 9; { const char* argvValue[2] = { shortValueTest, "2" }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,quint64))); args.addSupported('v', "value", "64-bit unsigned value " "short test", true); QVERIFY(static_cast<quint64>(args.value('v', value)) == static_cast<quint64>(2)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<quint64>(arguments.at(1).toULongLong()) == static_cast<quint64>(2)); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "4" #else "--value=4", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,quint64))); args.addSupported('v', "value", "64-bit unsigned value " "long test", true); QVERIFY(static_cast<quint64>(args.value('v', value)) == static_cast<quint64>(4)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<quint64>(arguments.at(1).toULongLong()) == static_cast<quint64>(4)); } { const char* argvValue[1] = { shortValueTest }; QArgs args(1, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,quint64))); args.addSupported('v', "value", "64-bit unsigned value " "short test fail", true); QVERIFY(static_cast<quint64>(args.value('v', value)) == static_cast<quint64>(9)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<quint64>(arguments.at(1).toULongLong()) == static_cast<quint64>(9)); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "4.45" #else "--value=4.45", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,quint64))); args.addSupported('v', "value", "64-bit unsigned value " "long test fail", true); QVERIFY(static_cast<quint64>(args.value('v', value)) == static_cast<quint64>(9)); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(static_cast<quint64>(arguments.at(1).toULongLong()) == static_cast<quint64>(9)); } } /// Test value QChar void valueQChar() { QChar value('9'); { const char* argvValue[2] = { shortValueTest, "2"}; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,QChar))); args.addSupported('v', "value", "QChar value short test", true); QVERIFY(args.value('v', value) == '2'); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toChar() == '2'); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "4" #else "--value=4", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,QChar))); args.addSupported('v', "value", "QChar value shot test", true); QVERIFY(args.value('v', value) == '4'); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toChar() == '4'); } { const char* argvValue[1] = { shortValueTest }; QArgs args(1, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,QChar))); args.addSupported('v', "value", "QChar value short test fail", true); QVERIFY(args.value('v', value) == '9'); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toChar() == '9'); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "\0" #else "--value=\0", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,QChar))); args.addSupported('v', "value", "QChar empty value " "long test fail", true); QVERIFY(args.value('v', value) == '9'); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toChar() == '9'); } } /// Test value QString void valueQString() { QString value("9"); { const char* argvValue[2] = { shortValueTest, "2" }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,QString))); args.addSupported('v', "value", "QString value short test", true); QVERIFY(args.value('v', value) == "2"); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toString() == "2"); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "4" #else "--value=4", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,QString))); args.addSupported('v', "value", "QString value long test", true); QVERIFY(args.value('v', value) == "4"); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toString() == "4"); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "a " #else "--value=a ", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,QString))); args.addSupported('v', "value", "QString emtpy spaced value " "long test", true); QVERIFY(args.value('v', value) == "a"); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toString() == "a"); } { const char* argvValue[1] = { shortValueTest }; QArgs args(1, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,QString))); args.addSupported('v', "value", "QString value short test fail", true); QVERIFY(args.value('v', value) == "9"); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toString() == "9"); } { const char* argvValue[2] = { #ifdef Q_OS_WIN32 "/value", "\0\0\0" #else "--value=\0\0\0", "" #endif }; QArgs args(2, argvValue); QSignalSpy valueSignal(&args, SIGNAL(argumentValue(QChar,QString))); args.addSupported('v', "value", "QString null value " "long test fail", true); QVERIFY(args.value('v', value) == "9"); QVERIFY(valueSignal.isValid()); QVERIFY(valueSignal.count() == 1); QList< QVariant > arguments(valueSignal.takeAt(0)); QVERIFY(arguments.at(0).toChar() == 'v'); QVERIFY(arguments.at(1).toString() == "9"); } } }; #endif QTEST_MAIN(QArgsUT)