--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/UNIT_TESTS/qargsut.hpp	Sat Jun 14 13:17:37 2014 +0000
@@ -0,0 +1,1966 @@
+/*******************************************************************************
+***  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)