# HG changeset patch
# User John Schneiderman <JohnMS@CodeGNU.com>
# Date 1402756927 0
# Node ID 2e08e35922c91d843a16c736df93981ee8f90970
# Parent  57cab94253bd66c2f326cef3e7d0619d26134916
Reduced the vebosity of the debug messages to just boundries. ti: -

diff -r 57cab94253bd -r 2e08e35922c9 doc/style.xml
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/doc/style.xml	Sat Jun 14 14:42:07 2014 +0000
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE QtCreatorCodeStyle>
+<!-- Written by QtCreator 3.1.1, 2014-06-14T08:33:07. -->
+<qtcreator>
+ <data>
+  <variable>CodeStyleData</variable>
+  <valuemap type="QVariantMap">
+   <value type="bool" key="AlignAssignments">false</value>
+   <value type="bool" key="AutoSpacesForTabs">false</value>
+   <value type="bool" key="BindStarToIdentifier">false</value>
+   <value type="bool" key="BindStarToLeftSpecifier">true</value>
+   <value type="bool" key="BindStarToRightSpecifier">false</value>
+   <value type="bool" key="BindStarToTypeName">true</value>
+   <value type="bool" key="ExtraPaddingForConditionsIfConfusingAlign">false</value>
+   <value type="bool" key="IndentAccessSpecifiers">false</value>
+   <value type="bool" key="IndentBlockBody">true</value>
+   <value type="bool" key="IndentBlockBraces">false</value>
+   <value type="bool" key="IndentBlocksRelativeToSwitchLabels">false</value>
+   <value type="bool" key="IndentClassBraces">false</value>
+   <value type="bool" key="IndentControlFlowRelativeToSwitchLabels">false</value>
+   <value type="bool" key="IndentDeclarationsRelativeToAccessSpecifiers">true</value>
+   <value type="bool" key="IndentEnumBraces">false</value>
+   <value type="bool" key="IndentFunctionBody">true</value>
+   <value type="bool" key="IndentFunctionBraces">false</value>
+   <value type="bool" key="IndentNamespaceBody">false</value>
+   <value type="bool" key="IndentNamespaceBraces">false</value>
+   <value type="int" key="IndentSize">5</value>
+   <value type="bool" key="IndentStatementsRelativeToSwitchLabels">true</value>
+   <value type="bool" key="IndentSwitchLabels">false</value>
+   <value type="int" key="PaddingMode">2</value>
+   <value type="bool" key="SpacesForTabs">false</value>
+   <value type="int" key="TabSize">5</value>
+  </valuemap>
+ </data>
+ <data>
+  <variable>DisplayName</variable>
+  <value type="QString">My ANSI variation</value>
+ </data>
+</qtcreator>
diff -r 57cab94253bd -r 2e08e35922c9 src/UNIT_TESTS/qargsut.hpp
--- a/src/UNIT_TESTS/qargsut.hpp	Sat Jun 14 14:21:12 2014 +0000
+++ b/src/UNIT_TESTS/qargsut.hpp	Sat Jun 14 14:42:07 2014 +0000
@@ -41,1926 +41,1926 @@
 
 
 /**
- * QArgs Unit Test
+ * @brief 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.
+ * @details 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;
+	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;
+	/// 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;
-    }
+		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);
+	/// 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);
+		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);
-    }
+		// 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 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");
+		// 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);
+		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 exception cases
+		try
+		{
+			args.addSupported('h', "question", "Short help test");
+			QVERIFY2(false, "Short help argument not caught");
+		}
+		catch (domain_error& error)
+		{
+			QVERIFY2(strlen(error.what()) > 0, "Missing Error Message.");
+		}
+		try
+		{
+			args.addSupported('?', "win-question",
+						   "Short help for Windows test");
+			QVERIFY2(false, "Short help argument for Windows not caught");
+		}
+		catch (domain_error& error)
+		{
+			QVERIFY2(strlen(error.what()) > 0, "Missing Error Message.");
+		}
+		try
+		{
+			args.addSupported('p', "help", "Long help test");
+			QVERIFY2(false, "Long help argument not caught");
+		}
+		catch (domain_error& error)
+		{
+			QVERIFY2(strlen(error.what()) > 0, "Missing Error Message.");
+		}
+		try
+		{
+			args.addSupported(' ', "aaaa", "Empty argument short test");
+			QVERIFY2(false, "Empty short argument not caught");
+		}
+		catch (logic_error& error)
+		{
+			QVERIFY2(strlen(error.what()) > 0, "Missing Error Message.");
+		}
+		try
+		{
+			args.addSupported('e', "   ", "Empty argument long test");
+			QVERIFY2(false, "Empty long argument not caught");
+		}
+		catch (logic_error& error)
+		{
+			QVERIFY2(strlen(error.what()) > 0, "Missing Error Message.");
+		}
+		try
+		{
+			args.addSupported('r', "required", "Required test", false, true);
+			QVERIFY2(false, "Required not caught");
+		}
+		catch (runtime_error& error)
+		{
+			QVERIFY2(strlen(error.what()) > 0, "Missing Error Message.");
+		}
+		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)
+		{
+			QVERIFY2(strlen(error.what()) > 0, "Missing Error Message.");
+		}
+		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)
+		{
+			QVERIFY2(strlen(error.what()) > 0, "Missing Error Message.");
+		}
+	}
 
-    /// 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");
+	/// 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();
+			QVERIFY(true);
+		}
+		catch(runtime_error& error)
+		{
+			QVERIFY2(strlen(error.what()) > 0, "Missing Error Message.");
+			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 not provided, but none "
+				    "listed as supported");
+		}
+		catch(logic_error& error)
+		{
+			QVERIFY2(strlen(error.what()) > 0, "Missing Error Message.");
+		}
+		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();
-	   }
-    }
+			args.verifySupport();
+			QVERIFY2(false, "Short & long arguments provided, but some are "
+				    "not listed as supported");
+		}
+		catch(runtime_error& error)
+		{
+			QVERIFY2(strlen(error.what()) > 0, "Missing Error Message.");
+		}
+	}
 
-    // Test argument list lock
-    void argumentListLock()
-    {
-	   try
-	   {
-		  QArgs args(ARGC, argv);
+	// 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();
-	   }
+			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)
+		{
+			QVERIFY2(strlen(error.what()) > 0, "Missing Error Message.");
+		}
 
-    }
+	}
 
-    /// 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");
+	/// 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);
-    }
+		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");
+	/// 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') == 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);
-	   }
-    }
+			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());
+	/// 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);
-    }
+		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);
+	/// Test marker accessor
+	void marker()
+	{
+		QArgs args(ARGC, argv);
 
-	   QVERIFY(args.marker() == MARKER);
-    }
+		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);
+	/// 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);
+		}
+		{
+			// 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);
+			QVERIFY(args.count() == 0);
+		}
+		{
+			QArgs args(ARGC, argv);
 
-		  // Valid arguments that are counted: -i, --double, -h, --help, -f
-		  QVERIFY(args.count() == 5);
-	   }
-    }
+			// 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 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&)));
+	/// 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");
+		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
-    }
+		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&)));
+	/// 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"));
-    }
+		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);
+	/// Test has argument
+	void hasArgument()
+	{
+		{
+			QArgs args(ARGC, argv);
 
-		  QVERIFY(args.hasArgument('f') == true);
-	   }
-	   {
-		  QArgs args(ARGC, argv);
+			QVERIFY(args.hasArgument('f') == true);
+		}
+		{
+			QArgs args(ARGC, argv);
 
-		  QVERIFY(args.hasArgument('p') == false);
-	   }
-    }
+			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 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)));
+	/// 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 "
+						   "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 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 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 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 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 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);
-	   }
+			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)));
+		// 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 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 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 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 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 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 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 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 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 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);
-	   }
-    }
+			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)));
+	/// 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 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 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 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));
-	   }
-    }
+			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)));
+	/// 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 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 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 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));
-	   }
-    }
+			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)));
+	/// 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 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 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 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));
-	   }
-    }
+			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)));
+	/// 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 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 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 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));
-	   }
-    }
+			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)));
+	/// 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 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 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 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));
-	   }
-    }
+			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)));
+	/// 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 "
+						   "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 "
+						   "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 "
+						   "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));
-	   }
-    }
+			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)));
+	/// 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 "
+						   "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 "
+						   "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 "
+						   "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));
-	   }
-    }
+			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)));
+	/// 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 "
+						   "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 "
+						   "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 "
+						   "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));
-	   }
-    }
+			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)));
+	/// 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 "
+						   "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 "
+						   "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 "
+						   "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));
-	   }
-    }
+			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)));
+	/// 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 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 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 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');
-	   }
-    }
+			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)));
+	/// 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 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 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 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 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");
-	   }
-    }
+			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)
diff -r 57cab94253bd -r 2e08e35922c9 src/qargs.cpp
--- a/src/qargs.cpp	Sat Jun 14 14:21:12 2014 +0000
+++ b/src/qargs.cpp	Sat Jun 14 14:42:07 2014 +0000
@@ -53,8 +53,6 @@
 template<>
 QTARGS_SHARED_EXPORT bool convertToValueType(const QString& value, qreal& converted)
 {
-    qDebug() << "convertToValueType(const QString&, qreal&)" << value
-		   << converted;
     bool conversionState;
     converted = value.toDouble(&conversionState);
     return conversionState;
@@ -63,8 +61,6 @@
 template<>
 QTARGS_SHARED_EXPORT bool convertToValueType(const QString& value, qint8& converted)
 {
-    qDebug() << "convertToValueType(const QString&, qint8&)" << value
-		   << converted;
     bool conversionState;
     converted = static_cast<qint8>(value.toShort(&conversionState));
     return conversionState;
@@ -73,8 +69,6 @@
 template<>
 QTARGS_SHARED_EXPORT bool convertToValueType(const QString& value, qint16& converted)
 {
-    qDebug() << "convertToValueType(const QString&, qint16&)" << value
-		   << converted;
     bool conversionState;
     converted = value.toShort(&conversionState);
     return conversionState;
@@ -83,8 +77,6 @@
 template<>
 QTARGS_SHARED_EXPORT bool convertToValueType(const QString& value, qint32& converted)
 {
-    qDebug() << "convertToValueType(const QString&, qint32&)" << value
-		   << converted;
     bool conversionState;
     converted = value.toLong(&conversionState);
     return conversionState;
@@ -93,8 +85,6 @@
 template<>
 QTARGS_SHARED_EXPORT bool convertToValueType(const QString& value, qint64& converted)
 {
-    qDebug() << "convertToValueType(const QString&, qint64&)" << value
-		   << converted;
     bool conversionState;
     converted = value.toLongLong(&conversionState);
     return conversionState;
@@ -103,8 +93,6 @@
 template<>
 QTARGS_SHARED_EXPORT bool convertToValueType(const QString& value, quint8& converted)
 {
-    qDebug() << "convertToValueType(const QString&, quint8&)" << value
-		   << converted;
     bool conversionState;
     converted = static_cast<quint8>(value.toShort(&conversionState));
     return conversionState;
@@ -113,8 +101,6 @@
 template<>
 QTARGS_SHARED_EXPORT bool convertToValueType(const QString& value, quint16& converted)
 {
-    qDebug() << "convertToValueType(const QString&, quint16&)" << value
-		   << converted;
     bool conversionState;
     converted = value.toUShort(&conversionState);
     return conversionState;
@@ -123,8 +109,6 @@
 template<>
 QTARGS_SHARED_EXPORT bool convertToValueType(const QString& value, quint32& converted)
 {
-    qDebug() << "convertToValueType(const QString&, quint32&)" << value
-		   << converted;
     bool conversionState;
     converted = value.toULong(&conversionState);
     return conversionState;
@@ -133,8 +117,6 @@
 template<>
 QTARGS_SHARED_EXPORT bool convertToValueType(const QString& value, quint64& converted)
 {
-    qDebug() << "convertToValueType(const QString&, quint64&)" << value
-		   << converted;
     bool conversionState;
     converted = value.toULongLong(&conversionState);
     return conversionState;
@@ -143,8 +125,6 @@
 template<>
 QTARGS_SHARED_EXPORT bool convertToValueType(const QString& value, QChar& converted)
 {
-    qDebug() << "convertToValueType(const QString&, QChar&)" << value
-		   << converted;
     bool valid;
     if (value.isEmpty())
 	   valid = false;
@@ -159,8 +139,6 @@
 template<>
 QTARGS_SHARED_EXPORT bool convertToValueType(const QString& value, QString& converted)
 {
-    qDebug() << "convertToValueType(const QString&, QString&)" << value
-		   << converted;
     converted = value;
     return true;
 }
@@ -174,7 +152,8 @@
     mIsLocked(false),
     mAreArgumentsVerified(false)
 {
-    qDebug() << "QArgs::QArgs(argc, const char*[])" << argc << *argv;
+    qDebug() << "QArgs::QArgs(argc, const char*[], Sensitivity)" << argc
+		   << *argv << caseing;
 
     for (int index(0); index < argc; ++index)
 	   this->mArguments.append(QString(argv[index]).trimmed());
@@ -196,7 +175,8 @@
     mIsLocked(false),
     mAreArgumentsVerified(false)
 {
-    qDebug() << "QArgs::QArgs(argc, char*[])" << argc << *argv;
+    qDebug() << "QArgs::QArgs(argc, char*[], Sensitivity)" << argc << *argv
+			 << caseing;
 
     for (int index(0); index < argc; ++index)
 	   this->mArguments.append(QString(argv[index]).trimmed());
@@ -212,19 +192,16 @@
 
 const QStringList& QArgs::arguments() const
 {
-    qDebug() << "QArgs::arguments()";
     return this->mArguments;
 }
 
 const QChar& QArgs::marker() const
 {
-    qDebug() << "QArgs::marker()";
     return ARGUMENT_MARKER;
 }
 
 qint32 QArgs::count() const
 {
-    qDebug() << "QArgs::count()";
     const QString LONG_MARKER(QString("%1%2").arg(ARGUMENT_MARKER).arg(
 			 ARGUMENT_MARKER));
     qint32 count(0);
@@ -239,11 +216,6 @@
 void QArgs::addSupported(const QChar& shortName, const QString& longName,
 	   const QString& description, bool takesValue, bool required)
 {
-    qDebug() << "QArgs::addSupported(QChar, QString, QString, bool, bool)" <<
-		  shortName << longName << description <<
-		  (takesValue ? "TakesValue" : "DoesNotTakeValue") <<
-		  (required ? "Required" : "NotRequired");
-
     // Verify short name is valid.
     if ((SHORT_HELP == shortName) || (OTHER_OS_SHORT_HELP == shortName))
 	   throw domain_error(tr("Cannot override short "
@@ -296,8 +268,6 @@
 
 bool QArgs::hasArgument(const QChar& shortName) const
 {
-    qDebug() << "QArgs::hasArgument(QChar)" << shortName;
-
     if ((-1 != shortNameIndex(shortName)) || (-1 != longNameIndex(shortName)))
 	   return true;
     else
@@ -306,14 +276,11 @@
 
 void QArgs::lock()
 {
-    qDebug() << "QArgs::lock()";
     this->mIsLocked = true;
 }
 
 bool QArgs::hasHelp() const
 {
-    qDebug() << "QArgs::hasHelp()";
-
     if ((-1 != shortNameIndex(SHORT_HELP)) ||
 		  (-1 != longNameIndex(SHORT_HELP)))
 	   return true;
@@ -361,8 +328,6 @@
 bool QArgs::value(const QChar& shortName, bool defaultValue,
 			   BooleanSupport types) const
 {
-    qDebug() << "QArgs::value(QChar, bool)" << shortName
-		  << (defaultValue ? "True" : "False");
     bool value(defaultValue);
     int shortIndex(shortNameIndex(shortName));
     int longIndex(longNameIndex(shortName));
@@ -409,7 +374,6 @@
 
 qreal QArgs::value(const QChar& shortName, qreal defaultValue) const
 {
-    qDebug() << "QArgs::value(QChar, qreal)" << shortName << defaultValue;
     qreal value(defaultValue);
     int shortIndex(shortNameIndex(shortName));
     int longIndex(longNameIndex(shortName));
@@ -436,7 +400,6 @@
 
 qint8 QArgs::value(const QChar& shortName, qint8 defaultValue) const
 {
-    qDebug() << "QArgs::value(QChar, qint8)" << shortName << defaultValue;
     qint8 value(defaultValue);
     int shortIndex(shortNameIndex(shortName));
     int longIndex(longNameIndex(shortName));
@@ -463,7 +426,6 @@
 
 qint16 QArgs::value(const QChar& shortName, qint16 defaultValue) const
 {
-    qDebug() << "QArgs::value(QChar, qint16)" << shortName << defaultValue;
     qint16 value(defaultValue);
     int shortIndex(shortNameIndex(shortName));
     int longIndex(longNameIndex(shortName));
@@ -490,7 +452,6 @@
 
 qint32 QArgs::value(const QChar& shortName, qint32 defaultValue) const
 {
-    qDebug() << "QArgs::value(QChar, qint32)" << shortName << defaultValue;
     qint32 value(defaultValue);
     int shortIndex(shortNameIndex(shortName));
     int longIndex(longNameIndex(shortName));
@@ -517,7 +478,6 @@
 
 qint64 QArgs::value(const QChar& shortName, qint64 defaultValue) const
 {
-    qDebug() << "QArgs::value(QChar, qint64)" << shortName << defaultValue;
     qint64 value(defaultValue);
     int shortIndex(shortNameIndex(shortName));
     int longIndex(longNameIndex(shortName));
@@ -544,7 +504,6 @@
 
 quint8 QArgs::value(const QChar& shortName, quint8 defaultValue) const
 {
-    qDebug() << "QArgs::value(QChar, quint8)" << shortName << defaultValue;
     quint8 value(defaultValue);
     int shortIndex(shortNameIndex(shortName));
     int longIndex(longNameIndex(shortName));
@@ -571,7 +530,6 @@
 
 quint16 QArgs::value(const QChar& shortName, quint16 defaultValue) const
 {
-    qDebug() << "QArgs::value(QChar, quint16)" << shortName << defaultValue;
     quint16 value(defaultValue);
     int shortIndex(shortNameIndex(shortName));
     int longIndex(longNameIndex(shortName));
@@ -598,7 +556,6 @@
 
 quint32 QArgs::value(const QChar& shortName, quint32 defaultValue) const
 {
-    qDebug() << "QArgs::value(QChar, quint32)" << shortName << defaultValue;
     quint32 value(defaultValue);
     int shortIndex(shortNameIndex(shortName));
     int longIndex(longNameIndex(shortName));
@@ -625,7 +582,6 @@
 
 quint64 QArgs::value(const QChar& shortName, quint64 defaultValue) const
 {
-    qDebug() << "QArgs::value(QChar, quint64)" << shortName << defaultValue;
     quint64 value(defaultValue);
     int shortIndex(shortNameIndex(shortName));
     int longIndex(longNameIndex(shortName));
@@ -653,7 +609,6 @@
 QChar QArgs::value(const QChar& shortName,
 	   const QChar& defaultValue) const
 {
-    qDebug() << "QArgs::value(QChar, QChar)" << shortName << defaultValue;
     QChar value;
     QString valueHolder;
     int shortIndex(shortNameIndex(shortName));
@@ -683,7 +638,6 @@
 QString QArgs::value(const QChar& shortName,
 	   const QString& defaultValue) const
 {
-    qDebug() << "QArgs::value(QChar, QString)" << shortName << defaultValue;
     QString value;
     int shortIndex(shortNameIndex(shortName));
     int longIndex(longNameIndex(shortName));
@@ -769,10 +723,9 @@
 
 #ifdef Q_OS_WIN32
     if (SHORT_HELP == name)
-	   index = this->mArguments.indexOf(QString("%1\\%2").arg(
+	   index = this->mArguments.indexOf(QString("%1%2").arg(
 			 ARGUMENT_MARKER).arg(SHORT_HELP));
 #endif
-    qDebug() << "Short index of " << name << "is" << index;
     return index;
 }
 
@@ -782,9 +735,6 @@
 
 #ifdef Q_OS_WIN32
     // Windows long options form is: /long-index-name value
-    qDebug() << "Windows long form:" << QString("%1%2").arg(
-				ARGUMENT_MARKER).arg(
-				this->mSupported.value(name).longName);
     index = this->mArguments.indexOf(
 			 QRegExp(QString("%1%2").arg(ARGUMENT_MARKER).arg(
 					   this->mSupported.value(name).longName)));
@@ -805,6 +755,5 @@
 	   index = this->mArguments.indexOf(QRegExp(QString("%1%2%3").arg(
 			 ARGUMENT_MARKER).arg(ARGUMENT_MARKER).arg(
 			 this->mSupported.value(name).longName)));
-    qDebug() << "Long index of " << name << "is" << index;
     return index;
 }