Moving submodule contents back.

author: Remko Tronçon <git@el-tramo.be> 2010-03-28 15:46:49 (GMT)
committer: Remko Tronçon <git@el-tramo.be> 2010-03-28 15:46:49 (GMT)
commit: f53a1ef582494458301b97bf6e546be52d7ff7e8 (patch)
tree: 7571b5cbcbd8a8f1dd1c966c9045b6cb69f0e295 /3rdParty/CppUnit
parent: 638345680d72ca6acaf123f2c8c1c391f696e371 (diff)
download: swift-contrib-f53a1ef582494458301b97bf6e546be52d7ff7e8.zip
swift-contrib-f53a1ef582494458301b97bf6e546be52d7ff7e8.tar.bz2
96 files changed, 9995 insertions, 0 deletions
diff --git a/3rdParty/CppUnit/.gitignore b/3rdParty/CppUnit/.gitignore
new file mode 100644
index 0000000..54a7bf6
--- /dev/null
+++ b/3rdParty/CppUnit/.gitignore
@@ -0,0 +1,4 @@
+*.o
+*.a
+*.lib
+*.obj
diff --git a/3rdParty/CppUnit/SConscript b/3rdParty/CppUnit/SConscript
new file mode 100644
index 0000000..95109e1
--- /dev/null
+++ b/3rdParty/CppUnit/SConscript
@@ -0,0 +1,55 @@
+Import("env")
+
+################################################################################
+# Module flags
+################################################################################
+
+if env["SCONS_STAGE"] == "flags" :
+	env["CPPUNIT_FLAGS"] = {
+			"CPPPATH": [env.Dir("src/include"), env.Dir(".")],
+			"LIBPATH": [env.Dir(".")],
+			"LIBS": ["CppUnit"]
+		}
+
+################################################################################
+# Build
+################################################################################
+
+if env["SCONS_STAGE"] == "build" :
+	myenv = env.Clone()
+	myenv.Append(CPPPATH = ["src/include", "."])
+	sources = [
+			"src/src/cppunit/TextTestRunner.cpp",
+			"src/src/cppunit/TextTestProgressListener.cpp",
+			"src/src/cppunit/BriefTestProgressListener.cpp",
+			"src/src/cppunit/TextOutputter.cpp",
+			"src/src/cppunit/XmlOutputter.cpp",
+			"src/src/cppunit/XmlElement.cpp",
+			"src/src/cppunit/XmlDocument.cpp",
+			"src/src/cppunit/StringTools.cpp",
+			"src/src/cppunit/DefaultProtector.cpp",
+			"src/src/cppunit/Protector.cpp",
+			"src/src/cppunit/ProtectorChain.cpp",
+			"src/src/cppunit/SynchronizedObject.cpp",
+			"src/src/cppunit/SourceLine.cpp",
+			"src/src/cppunit/TestRunner.cpp",
+			"src/src/cppunit/TestFactoryRegistry.cpp",
+			"src/src/cppunit/TestSuite.cpp",
+			"src/src/cppunit/TestSuiteBuilderContext.cpp",
+			"src/src/cppunit/TestResult.cpp",
+			"src/src/cppunit/TestResultCollector.cpp",
+			"src/src/cppunit/TestSuccessListener.cpp",
+			"src/src/cppunit/TestComposite.cpp",
+			"src/src/cppunit/TestCase.cpp",
+			"src/src/cppunit/TestFailure.cpp",
+			"src/src/cppunit/TestLeaf.cpp",
+			"src/src/cppunit/TestNamer.cpp",
+			"src/src/cppunit/Asserter.cpp",
+			"src/src/cppunit/TypeInfoHelper.cpp",
+			"src/src/cppunit/Exception.cpp",
+			"src/src/cppunit/Message.cpp",
+			"src/src/cppunit/AdditionalMessage.cpp",
+			"src/src/cppunit/Test.cpp",
+			"src/src/cppunit/TestPath.cpp"
+		]
+	myenv.StaticLibrary("CppUnit", sources)
diff --git a/3rdParty/CppUnit/cppunit/config-auto.h b/3rdParty/CppUnit/cppunit/config-auto.h
new file mode 100644
index 0000000..58b3d6e
--- /dev/null
+++ b/3rdParty/CppUnit/cppunit/config-auto.h
@@ -0,0 +1,161 @@
+#ifndef _INCLUDE_CPPUNIT_CONFIG_AUTO_H
+#define _INCLUDE_CPPUNIT_CONFIG_AUTO_H 1
+ 
+/* include/cppunit/config-auto.h. Generated automatically at end of configure. */
+/* config/config.h.  Generated by configure.  */
+/* config/config.h.in.  Generated from configure.in by autoheader.  */
+
+/* define if library uses std::string::compare(string,pos,n) */
+/* #undef CPPUNIT_FUNC_STRING_COMPARE_STRING_FIRST */
+
+
+#define CPPUNIT_HAVE_CPP_CAST
+
+/* define if the library defines strstream */
+#ifndef CPPUNIT_HAVE_CLASS_STRSTREAM 
+#define CPPUNIT_HAVE_CLASS_STRSTREAM  1 
+#endif
+
+/* Define to 1 if you have the <cmath> header file. */
+#ifndef CPPUNIT_HAVE_CMATH 
+#define CPPUNIT_HAVE_CMATH  1 
+#endif
+
+/* Define if you have the GNU dld library. */
+/* #undef CPPUNIT_HAVE_DLD */
+
+/* Define to 1 if you have the `dlerror' function. */
+#ifndef CPPUNIT_HAVE_DLERROR 
+#define CPPUNIT_HAVE_DLERROR  1 
+#endif
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#ifndef CPPUNIT_HAVE_DLFCN_H 
+#define CPPUNIT_HAVE_DLFCN_H  1 
+#endif
+
+/* define if the compiler supports GCC C++ ABI name demangling */
+#ifndef CPPUNIT_HAVE_GCC_ABI_DEMANGLE 
+#define CPPUNIT_HAVE_GCC_ABI_DEMANGLE  1 
+#endif
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#ifndef CPPUNIT_HAVE_INTTYPES_H 
+#define CPPUNIT_HAVE_INTTYPES_H  1 
+#endif
+
+/* Define if you have the libdl library or equivalent. */
+#ifndef CPPUNIT_HAVE_LIBDL 
+#define CPPUNIT_HAVE_LIBDL  1 
+#endif
+
+/* Define to 1 if you have the <memory.h> header file. */
+#ifndef CPPUNIT_HAVE_MEMORY_H 
+#define CPPUNIT_HAVE_MEMORY_H  1 
+#endif
+
+/* define to 1 if the compiler implements namespaces */
+#ifndef CPPUNIT_HAVE_NAMESPACES 
+#define CPPUNIT_HAVE_NAMESPACES  1 
+#endif
+
+/* define if the compiler supports Run-Time Type Identification */
+#ifndef CPPUNIT_HAVE_RTTI 
+#define CPPUNIT_HAVE_RTTI  1 
+#endif
+
+/* Define if you have the shl_load function. */
+/* #undef CPPUNIT_HAVE_SHL_LOAD */
+
+/* define if the compiler has stringstream */
+#ifndef CPPUNIT_HAVE_SSTREAM 
+#define CPPUNIT_HAVE_SSTREAM  1 
+#endif
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#ifndef CPPUNIT_HAVE_STDINT_H 
+#define CPPUNIT_HAVE_STDINT_H  1 
+#endif
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#ifndef CPPUNIT_HAVE_STDLIB_H 
+#define CPPUNIT_HAVE_STDLIB_H  1 
+#endif
+
+/* Define to 1 if you have the <strings.h> header file. */
+#ifndef CPPUNIT_HAVE_STRINGS_H 
+#define CPPUNIT_HAVE_STRINGS_H  1 
+#endif
+
+/* Define to 1 if you have the <string.h> header file. */
+#ifndef CPPUNIT_HAVE_STRING_H 
+#define CPPUNIT_HAVE_STRING_H  1 
+#endif
+
+/* Define to 1 if you have the <strstream> header file. */
+#ifndef CPPUNIT_HAVE_STRSTREAM 
+#define CPPUNIT_HAVE_STRSTREAM  1 
+#endif
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#ifndef CPPUNIT_HAVE_SYS_STAT_H 
+#define CPPUNIT_HAVE_SYS_STAT_H  1 
+#endif
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#ifndef CPPUNIT_HAVE_SYS_TYPES_H 
+#define CPPUNIT_HAVE_SYS_TYPES_H  1 
+#endif
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#ifndef CPPUNIT_HAVE_UNISTD_H 
+#define CPPUNIT_HAVE_UNISTD_H  1 
+#endif
+
+/* Name of package */
+#ifndef CPPUNIT_PACKAGE 
+#define CPPUNIT_PACKAGE  "cppunit" 
+#endif
+
+/* Define to the address where bug reports for this package should be sent. */
+#ifndef CPPUNIT_PACKAGE_BUGREPORT 
+#define CPPUNIT_PACKAGE_BUGREPORT  "" 
+#endif
+
+/* Define to the full name of this package. */
+#ifndef CPPUNIT_PACKAGE_NAME 
+#define CPPUNIT_PACKAGE_NAME  "" 
+#endif
+
+/* Define to the full name and version of this package. */
+#ifndef CPPUNIT_PACKAGE_STRING 
+#define CPPUNIT_PACKAGE_STRING  "" 
+#endif
+
+/* Define to the one symbol short name of this package. */
+#ifndef CPPUNIT_PACKAGE_TARNAME 
+#define CPPUNIT_PACKAGE_TARNAME  "" 
+#endif
+
+/* Define to the version of this package. */
+#ifndef CPPUNIT_PACKAGE_VERSION 
+#define CPPUNIT_PACKAGE_VERSION  "" 
+#endif
+
+/* Define to 1 if you have the ANSI C header files. */
+#ifndef CPPUNIT_STDC_HEADERS 
+#define CPPUNIT_STDC_HEADERS  1 
+#endif
+
+/* Define to 1 to use type_info::name() for class names */
+#ifndef CPPUNIT_USE_TYPEINFO_NAME 
+#define CPPUNIT_USE_TYPEINFO_NAME  CPPUNIT_HAVE_RTTI 
+#endif
+
+/* Version number of package */
+#ifndef CPPUNIT_VERSION 
+#define CPPUNIT_VERSION  "1.12.0" 
+#endif
+ 
+/* _INCLUDE_CPPUNIT_CONFIG_AUTO_H */
+#endif
diff --git a/3rdParty/CppUnit/src/COPYING b/3rdParty/CppUnit/src/COPYING
new file mode 100644
index 0000000..b1e3f5a
--- /dev/null
+++ b/3rdParty/CppUnit/src/COPYING
@@ -0,0 +1,504 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
diff --git a/3rdParty/CppUnit/src/include/cppunit/AdditionalMessage.h b/3rdParty/CppUnit/src/include/cppunit/AdditionalMessage.h
new file mode 100644
index 0000000..917d754
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/AdditionalMessage.h
@@ -0,0 +1,76 @@
+#ifndef CPPUNIT_ADDITIONALMESSAGE_H
+#define CPPUNIT_ADDITIONALMESSAGE_H
+
+#include <cppunit/Message.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+/*! \brief An additional Message for assertions.
+ * \ingroup CreatingNewAssertions
+ *
+ * Provides a implicit constructor that takes a single string. This allow this
+ * class to be used as the message arguments in macros.
+ *
+ * The constructed object is either a Message with a single detail string if
+ * a string was passed to the macro, or a copy of the Message passed to the macro.
+ *
+ * Here is an example of usage:
+ * \code
+ * 
+ *   void checkStringEquals( const std::string &expected,
+ *                          const std::string &actual,
+ *                           const CppUnit::SourceLine &sourceLine,
+ *                           const CppUnit::AdditionalMessage &message );
+ *  
+ *   #define XTLUT_ASSERT_STRING_EQUAL_MESSAGE( expected, actual, message )  \
+ *     ::XtlUt::Impl::checkStringEquals( ::Xtl::toString(expected),        \
+ *                                       ::Xtl::toString(actual),          \
+ *                                       CPPUNIT_SOURCELINE(),             \
+ *                                       message )
+ * \endcode
+ *
+ * In the previous example, the user can specify a simple string for \a message,
+ * or a complex Message object.
+ *
+ * \see Message
+ */
+class CPPUNIT_API AdditionalMessage : public Message
+{
+public:
+  typedef Message SuperClass;
+
+  /// Constructs an empty Message.
+  AdditionalMessage();
+
+  /*! \brief Constructs a Message with the specified detail string.
+   * \param detail1 Detail string of the message. If empty, then it is not added.
+   */
+  AdditionalMessage( const std::string &detail1 );
+
+  /*! \brief Constructs a Message with the specified detail string.
+   * \param detail1 Detail string of the message. If empty, then it is not added.
+   */
+  AdditionalMessage( const char *detail1 );
+
+  /*! \brief Constructs a copy of the specified message.
+   * \param other Message to copy.
+   */
+  AdditionalMessage( const Message &other );
+
+  /*! \brief Assignment operator.
+   * \param other Message to copy.
+   * \return Reference on this object.
+   */
+  AdditionalMessage &operator =( const Message &other );
+
+private:
+};
+
+
+CPPUNIT_NS_END
+
+
+
+#endif  // CPPUNIT_ADDITIONALMESSAGE_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/Asserter.h b/3rdParty/CppUnit/src/include/cppunit/Asserter.h
new file mode 100644
index 0000000..94dadaa
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/Asserter.h
@@ -0,0 +1,143 @@
+#ifndef CPPUNIT_ASSERTER_H
+#define CPPUNIT_ASSERTER_H
+
+#include <cppunit/AdditionalMessage.h>
+#include <cppunit/SourceLine.h>
+#include <string>
+
+CPPUNIT_NS_BEGIN
+
+
+class Message;
+
+
+/*! \brief A set of functions to help writing assertion macros.
+ * \ingroup CreatingNewAssertions
+ *
+ * Here is an example of assertion, a simplified version of the
+ * actual assertion implemented in examples/cppunittest/XmlUniformiser.h:
+ * \code
+ * #include <cppunit/SourceLine.h>
+ * #include <cppunit/TestAssert.h>
+ * 
+ * void 
+ * checkXmlEqual( std::string expectedXml,
+ *                std::string actualXml,
+ *                CppUnit::SourceLine sourceLine )
+ * {
+ *   std::string expected = XmlUniformiser( expectedXml ).stripped();
+ *   std::string actual = XmlUniformiser( actualXml ).stripped();
+ * 
+ *   if ( expected == actual )
+ *     return;
+ * 
+ *   ::CppUnit::Asserter::failNotEqual( expected,
+ *                                      actual,
+ *                                      sourceLine );
+ * }
+ * 
+ * /// Asserts that two XML strings are equivalent.
+ * #define CPPUNITTEST_ASSERT_XML_EQUAL( expected, actual ) \
+ *     checkXmlEqual( expected, actual,                     \
+ *                    CPPUNIT_SOURCELINE() )
+ * \endcode
+ */
+struct Asserter
+{
+  /*! \brief Throws a Exception with the specified message and location.
+   */
+  static void CPPUNIT_API fail( const Message &message, 
+                                const SourceLine &sourceLine = SourceLine() );
+
+  /*! \brief Throws a Exception with the specified message and location.
+   * \deprecated Use fail( Message, SourceLine ) instead.
+   */
+  static void CPPUNIT_API fail( std::string message, 
+                                const SourceLine &sourceLine = SourceLine() );
+
+  /*! \brief Throws a Exception with the specified message and location.
+   * \param shouldFail if \c true then the exception is thrown. Otherwise
+   *                   nothing happen.
+   * \param message Message explaining the assertion failiure.
+   * \param sourceLine Location of the assertion.
+   */
+  static void CPPUNIT_API failIf( bool shouldFail, 
+                                  const Message &message, 
+                                  const SourceLine &sourceLine = SourceLine() );
+
+  /*! \brief Throws a Exception with the specified message and location.
+   * \deprecated Use failIf( bool, Message, SourceLine ) instead.
+   * \param shouldFail if \c true then the exception is thrown. Otherwise
+   *                   nothing happen.
+   * \param message Message explaining the assertion failiure.
+   * \param sourceLine Location of the assertion.
+   */
+  static void CPPUNIT_API failIf( bool shouldFail, 
+                                  std::string message, 
+                                  const SourceLine &sourceLine = SourceLine() );
+
+  /*! \brief Returns a expected value string for a message.
+   * Typically used to create 'not equal' message, or to check that a message
+   * contains the expected content when writing unit tests for your custom 
+   * assertions.
+   *
+   * \param expectedValue String that represents the expected value.
+   * \return \a expectedValue prefixed with "Expected: ".
+   * \see makeActual().
+   */
+  static std::string CPPUNIT_API makeExpected( const std::string &expectedValue );
+
+  /*! \brief Returns an actual value string for a message.
+   * Typically used to create 'not equal' message, or to check that a message
+   * contains the expected content when writing unit tests for your custom 
+   * assertions.
+   *
+   * \param actualValue String that represents the actual value.
+   * \return \a actualValue prefixed with "Actual  : ".
+   * \see makeExpected().
+   */
+  static std::string CPPUNIT_API makeActual( const std::string &actualValue );
+
+  static Message CPPUNIT_API makeNotEqualMessage( const std::string &expectedValue,
+                                                  const std::string &actualValue,
+                                                  const AdditionalMessage &additionalMessage = AdditionalMessage(),
+                                                  const std::string &shortDescription = "equality assertion failed");
+
+  /*! \brief Throws an Exception with the specified message and location.
+   * \param expected Text describing the expected value.
+   * \param actual Text describing the actual value.
+   * \param sourceLine Location of the assertion.
+   * \param additionalMessage Additional message. Usually used to report
+   *                          what are the differences between the expected and actual value.
+   * \param shortDescription Short description for the failure message.
+   */
+  static void CPPUNIT_API failNotEqual( std::string expected, 
+                                        std::string actual, 
+                                        const SourceLine &sourceLine,
+                                        const AdditionalMessage &additionalMessage = AdditionalMessage(),
+                                        std::string shortDescription = "equality assertion failed" );
+
+  /*! \brief Throws an Exception with the specified message and location.
+   * \param shouldFail if \c true then the exception is thrown. Otherwise
+   *                   nothing happen.
+   * \param expected Text describing the expected value.
+   * \param actual Text describing the actual value.
+   * \param sourceLine Location of the assertion.
+   * \param additionalMessage Additional message. Usually used to report
+   *                          where the "difference" is located.
+   * \param shortDescription Short description for the failure message.
+   */
+  static void CPPUNIT_API failNotEqualIf( bool shouldFail,
+                                          std::string expected, 
+                                          std::string actual, 
+                                          const SourceLine &sourceLine,
+                                          const AdditionalMessage &additionalMessage = AdditionalMessage(),
+                                          std::string shortDescription = "equality assertion failed" );
+
+};
+
+
+CPPUNIT_NS_END
+
+
+#endif  // CPPUNIT_ASSERTER_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/BriefTestProgressListener.h b/3rdParty/CppUnit/src/include/cppunit/BriefTestProgressListener.h
new file mode 100644
index 0000000..137ca44
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/BriefTestProgressListener.h
@@ -0,0 +1,43 @@
+#ifndef CPPUNIT_BRIEFTESTPROGRESSLISTENER_H
+#define CPPUNIT_BRIEFTESTPROGRESSLISTENER_H
+
+#include <cppunit/TestListener.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+/*! \brief TestListener that prints the name of each test before running it.
+ * \ingroup TrackingTestExecution
+ */
+class CPPUNIT_API BriefTestProgressListener : public TestListener
+{
+public:
+  /*! Constructs a BriefTestProgressListener object.
+   */
+  BriefTestProgressListener();
+
+  /// Destructor.
+  virtual ~BriefTestProgressListener();
+
+  void startTest( Test *test );
+
+  void addFailure( const TestFailure &failure );
+
+  void endTest( Test *test );
+
+private:
+  /// Prevents the use of the copy constructor.
+  BriefTestProgressListener( const BriefTestProgressListener &copy );
+
+  /// Prevents the use of the copy operator.
+  void operator =( const BriefTestProgressListener &copy );
+
+private:
+  bool m_lastTestFailed;
+};
+
+
+CPPUNIT_NS_END
+
+#endif  // CPPUNIT_BRIEFTESTPROGRESSLISTENER_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/Exception.h b/3rdParty/CppUnit/src/include/cppunit/Exception.h
new file mode 100644
index 0000000..bf5fcac
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/Exception.h
@@ -0,0 +1,90 @@
+#ifndef CPPUNIT_EXCEPTION_H
+#define CPPUNIT_EXCEPTION_H
+
+#include <cppunit/Portability.h>
+#include <cppunit/Message.h>
+#include <cppunit/SourceLine.h>
+#include <exception>
+
+
+CPPUNIT_NS_BEGIN
+
+
+/*! \brief Exceptions thrown by failed assertions.
+ * \ingroup BrowsingCollectedTestResult
+ *
+ * Exception is an exception that serves
+ * descriptive strings through its what() method
+ */
+class CPPUNIT_API Exception : public std::exception
+{
+public:
+  /*! \brief Constructs the exception with the specified message and source location.
+   * \param message Message associated to the exception.
+   * \param sourceLine Source location related to the exception.
+   */
+  Exception( const Message &message = Message(), 
+             const SourceLine &sourceLine = SourceLine() );
+
+#ifdef CPPUNIT_ENABLE_SOURCELINE_DEPRECATED
+  /*!
+   * \deprecated Use other constructor instead.
+   */
+  Exception( std::string  message, 
+	     long lineNumber, 
+	     std::string fileName );
+#endif
+
+  /*! \brief Constructs a copy of an exception.
+   * \param other Exception to copy.
+   */
+  Exception( const Exception &other );
+
+  /// Destructs the exception
+  virtual ~Exception() throw();
+
+  /// Performs an assignment
+  Exception &operator =( const Exception &other );
+
+  /// Returns descriptive message
+  const char *what() const throw();
+
+  /// Location where the error occured
+  SourceLine sourceLine() const;
+
+  /// Message related to the exception.
+  Message message() const;
+
+  /// Set the message.
+  void setMessage( const Message &message );
+
+#ifdef CPPUNIT_ENABLE_SOURCELINE_DEPRECATED
+  /// The line on which the error occurred
+  long lineNumber() const;
+
+  /// The file in which the error occurred
+  std::string fileName() const;
+
+  static const std::string UNKNOWNFILENAME;
+  static const long UNKNOWNLINENUMBER;
+#endif
+
+  /// Clones the exception.
+  virtual Exception *clone() const;
+
+protected:
+  // VC++ does not recognize call to parent class when prefixed
+  // with a namespace. This is a workaround.
+  typedef std::exception SuperClass;
+
+  Message m_message;
+  SourceLine m_sourceLine;
+  std::string m_whatMessage;
+};
+
+
+CPPUNIT_NS_END
+
+
+#endif // CPPUNIT_EXCEPTION_H
+
diff --git a/3rdParty/CppUnit/src/include/cppunit/Message.h b/3rdParty/CppUnit/src/include/cppunit/Message.h
new file mode 100644
index 0000000..1ae51cc
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/Message.h
@@ -0,0 +1,156 @@
+#ifndef CPPUNIT_MESSAGE_H
+#define CPPUNIT_MESSAGE_H
+
+#include <cppunit/Portability.h>
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( push )
+#pragma warning( disable: 4251 )  // X needs to have dll-interface to be used by clients of class Z
+#endif
+
+#include <cppunit/portability/CppUnitDeque.h>
+#include <string>
+
+
+CPPUNIT_NS_BEGIN
+
+
+#if CPPUNIT_NEED_DLL_DECL
+//  template class CPPUNIT_API std::deque<std::string>;
+#endif
+
+/*! \brief Message associated to an Exception.
+ * \ingroup CreatingNewAssertions
+ *  A message is composed of two items:
+ *  - a short description (~20/30 characters)
+ *  - a list of detail strings
+ *
+ *  The short description is used to indicate how the detail strings should be
+ *  interpreted. It usually indicates the failure types, such as
+ *  "assertion failed", "forced failure", "unexpected exception caught",
+ *  "equality assertion failed"... It should not contains new line character (\n).
+ *
+ *  Detail strings are used to provide more information about the failure. It
+ *  can contains the asserted expression, the expected and actual values in an
+ *  equality assertion, some addional messages... Detail strings can contains
+ *  new line characters (\n).
+ */
+class CPPUNIT_API Message
+{
+public:
+  Message();
+
+  // Ensure thread-safe copy by detaching the string.
+  Message( const Message &other );
+
+  explicit Message( const std::string &shortDescription );
+
+  Message( const std::string &shortDescription,
+           const std::string &detail1 );
+
+  Message( const std::string &shortDescription,
+           const std::string &detail1,
+           const std::string &detail2 );
+
+  Message( const std::string &shortDescription,
+           const std::string &detail1,
+           const std::string &detail2,
+           const std::string &detail3 );
+
+  Message &operator =( const Message &other );
+
+  /*! \brief Returns the short description.
+   * \return Short description.
+   */
+  const std::string &shortDescription() const;
+
+  /*! \brief Returns the number of detail string.
+   * \return Number of detail string.
+   */
+  int detailCount() const;
+
+  /*! \brief Returns the detail at the specified index.
+   * \param index Zero based index of the detail string to return.
+   * \returns Detail string at the specified index.
+   * \exception std::invalid_argument if \a index < 0 or index >= detailCount().
+   */
+  std::string detailAt( int index ) const;
+
+  /*! \brief Returns a string that represents a list of the detail strings.
+   *
+   * Example:
+   * \code
+   * Message message( "not equal", "Expected: 3", "Actual: 7" );
+   * std::string details = message.details();
+   * // details contains:
+   * // "- Expected: 3\n- Actual: 7\n"  \endcode
+   *
+   * \return A string that is a concatenation of all the detail strings. Each detail
+   *         string is prefixed with '- ' and suffixed with '\n' before being
+   *         concatenated to the other.
+   */
+  std::string details() const;
+
+  /*! \brief Removes all detail strings.
+   */
+  void clearDetails();
+
+  /*! \brief Adds a single detail string.
+   * \param detail Detail string to add.
+   */
+  void addDetail( const std::string &detail );
+
+  /*! \brief Adds two detail strings.
+   * \param detail1 Detail string to add.
+   * \param detail2 Detail string to add.
+   */
+  void addDetail( const std::string &detail1,
+                  const std::string &detail2 );
+
+  /*! \brief Adds three detail strings.
+   * \param detail1 Detail string to add.
+   * \param detail2 Detail string to add.
+   * \param detail3 Detail string to add.
+   */
+  void addDetail( const std::string &detail1,
+                  const std::string &detail2,
+                  const std::string &detail3 );
+
+  /*! \brief Adds the detail strings of the specified message.
+   * \param message All the detail strings of this message are added to this one.
+   */
+  void addDetail( const Message &message );
+
+  /*! \brief Sets the short description.
+   * \param shortDescription New short description.
+   */
+  void setShortDescription( const std::string &shortDescription );
+
+  /*! \brief Tests if a message is identical to another one.
+   * \param other Message this message is compared to.
+   * \return \c true if the two message are identical, \c false otherwise.
+   */
+  bool operator ==( const Message &other ) const;
+
+  /*! \brief Tests if a message is different from another one.
+   * \param other Message this message is compared to.
+   * \return \c true if the two message are not identical, \c false otherwise.
+   */
+  bool operator !=( const Message &other ) const;
+
+private:
+  std::string m_shortDescription;
+
+  typedef CppUnitDeque<std::string> Details;
+  Details m_details;
+};
+
+
+CPPUNIT_NS_END
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( pop )
+#endif
+
+
+#endif  // CPPUNIT_MESSAGE_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/Outputter.h b/3rdParty/CppUnit/src/include/cppunit/Outputter.h
new file mode 100644
index 0000000..f31d681
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/Outputter.h
@@ -0,0 +1,26 @@
+#ifndef CPPUNIT_OUTPUTTER_H
+#define CPPUNIT_OUTPUTTER_H
+
+#include <cppunit/Portability.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+/*! \brief Abstract outputter to print test result summary.
+ * \ingroup WritingTestResult
+ */
+class CPPUNIT_API Outputter
+{
+public:
+  /// Destructor.
+  virtual ~Outputter() {}
+
+  virtual void write() =0;
+};
+
+
+CPPUNIT_NS_END
+
+
+#endif  // CPPUNIT_OUTPUTTER_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/Portability.h b/3rdParty/CppUnit/src/include/cppunit/Portability.h
new file mode 100644
index 0000000..ddf0316
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/Portability.h
@@ -0,0 +1,177 @@
+#ifndef CPPUNIT_PORTABILITY_H
+#define CPPUNIT_PORTABILITY_H
+
+#if defined(_WIN32) && !defined(WIN32)
+# define WIN32 1
+#endif
+
+/* include platform specific config */
+#if defined(__BORLANDC__)
+#  include <cppunit/config/config-bcb5.h>
+#elif defined (_MSC_VER)
+#  if _MSC_VER == 1200 && defined(_WIN32_WCE) //evc4
+#    include <cppunit/config/config-evc4.h>
+#  else
+#    include <cppunit/config/config-msvc6.h>
+#  endif
+#else
+#    include <cppunit/config-auto.h>
+#endif
+
+// Version number of package
+#ifndef CPPUNIT_VERSION 
+#define CPPUNIT_VERSION  "1.12.0"
+#endif
+ 
+#include <cppunit/config/CppUnitApi.h>    // define CPPUNIT_API & CPPUNIT_NEED_DLL_DECL
+#include <cppunit/config/SelectDllLoader.h>
+
+
+/* Options that the library user may switch on or off.
+ * If the user has not done so, we chose default values.
+ */
+
+
+/* Define to 1 if you wish to have the old-style macros
+   assert(), assertEqual(), assertDoublesEqual(), and assertLongsEqual() */
+#if !defined(CPPUNIT_ENABLE_NAKED_ASSERT)
+# define CPPUNIT_ENABLE_NAKED_ASSERT          0
+#endif
+
+/* Define to 1 if you wish to have the old-style CU_TEST family
+   of macros. */
+#if !defined(CPPUNIT_ENABLE_CU_TEST_MACROS)
+# define CPPUNIT_ENABLE_CU_TEST_MACROS        0
+#endif
+
+/* Define to 1 if the preprocessor expands (#foo) to "foo" (quotes incl.) 
+   I don't think there is any C preprocess that does NOT support this! */
+#if !defined(CPPUNIT_HAVE_CPP_SOURCE_ANNOTATION)
+# define CPPUNIT_HAVE_CPP_SOURCE_ANNOTATION   1
+#endif
+
+/* Assumes that STL and CppUnit are in global space if the compiler does not
+   support namespace. */
+#if !defined(CPPUNIT_HAVE_NAMESPACES)
+# if !defined(CPPUNIT_NO_NAMESPACE)
+#  define CPPUNIT_NO_NAMESPACE 1
+# endif // !defined(CPPUNIT_NO_NAMESPACE)
+# if !defined(CPPUNIT_NO_STD_NAMESPACE)
+#  define CPPUNIT_NO_STD_NAMESPACE 1
+# endif // !defined(CPPUNIT_NO_STD_NAMESPACE)
+#endif // !defined(CPPUNIT_HAVE_NAMESPACES)
+
+/* Define CPPUNIT_STD_NEED_ALLOCATOR to 1 if you need to specify
+ * the allocator you used when instantiating STL container. Typically
+ * used for compilers that do not support template default parameter.
+ * CPPUNIT_STD_ALLOCATOR will be used as the allocator. Default is
+ * std::allocator. On some compilers, you may need to change this to
+ * std::allocator<T>.
+ */
+#if CPPUNIT_STD_NEED_ALLOCATOR
+# if !defined(CPPUNIT_STD_ALLOCATOR)
+#  define CPPUNIT_STD_ALLOCATOR std::allocator
+# endif // !defined(CPPUNIT_STD_ALLOCATOR)
+#endif // defined(CPPUNIT_STD_NEED_ALLOCATOR)
+
+
+// Compiler error location format for CompilerOutputter
+// If not define, assumes that it's gcc
+// See class CompilerOutputter for format.
+#if !defined(CPPUNIT_COMPILER_LOCATION_FORMAT)
+#if defined(__GNUC__) && ( defined(__APPLE_CPP__) || defined(__APPLE_CC__) )
+// gcc/Xcode integration on Mac OS X
+# define CPPUNIT_COMPILER_LOCATION_FORMAT "%p:%l: " 
+#else
+# define CPPUNIT_COMPILER_LOCATION_FORMAT "%f:%l:"
+#endif
+#endif
+
+// If CPPUNIT_HAVE_CPP_CAST is defined, then c++ style cast will be used,
+// otherwise, C style cast are used.
+#if defined( CPPUNIT_HAVE_CPP_CAST )
+# define CPPUNIT_CONST_CAST( TargetType, pointer ) \
+    const_cast<TargetType>( pointer )
+
+# define CPPUNIT_STATIC_CAST( TargetType, pointer ) \
+    static_cast<TargetType>( pointer )
+#else // defined( CPPUNIT_HAVE_CPP_CAST )
+# define CPPUNIT_CONST_CAST( TargetType, pointer ) \
+    ((TargetType)( pointer ))
+# define CPPUNIT_STATIC_CAST( TargetType, pointer ) \
+    ((TargetType)( pointer ))
+#endif // defined( CPPUNIT_HAVE_CPP_CAST )
+
+// If CPPUNIT_NO_STD_NAMESPACE is defined then STL are in the global space.
+// => Define macro 'std' to nothing
+#if defined(CPPUNIT_NO_STD_NAMESPACE)
+# undef std
+# define std
+#endif  // defined(CPPUNIT_NO_STD_NAMESPACE)
+
+// If CPPUNIT_NO_NAMESPACE is defined, then put CppUnit classes in the
+// global namespace: the compiler does not support namespace.
+#if defined(CPPUNIT_NO_NAMESPACE)
+# define CPPUNIT_NS_BEGIN
+# define CPPUNIT_NS_END
+# define CPPUNIT_NS
+#else   // defined(CPPUNIT_NO_NAMESPACE)
+# define CPPUNIT_NS_BEGIN namespace CppUnit {
+# define CPPUNIT_NS_END }
+# define CPPUNIT_NS CppUnit
+#endif  // defined(CPPUNIT_NO_NAMESPACE)
+
+/*! Stringize a symbol.
+ * 
+ * Use this macro to convert a preprocessor symbol to a string.
+ *
+ * Example of usage:
+ * \code
+ * #define CPPUNIT_PLUGIN_EXPORTED_NAME cppunitTestPlugIn
+ * const char *name = CPPUNIT_STRINGIZE( CPPUNIT_PLUGIN_EXPORTED_NAME );
+ * \endcode
+ */
+#define CPPUNIT_STRINGIZE( symbol ) _CPPUNIT_DO_STRINGIZE( symbol )
+
+/// \internal
+#define _CPPUNIT_DO_STRINGIZE( symbol ) #symbol
+
+/*! Joins to symbol after expanding them into string.
+ *
+ * Use this macro to join two symbols. Example of usage:
+ *
+ * \code
+ * #define MAKE_UNIQUE_NAME(prefix) CPPUNIT_JOIN( prefix, __LINE__ )
+ * \endcode
+ *
+ * The macro defined in the example concatenate a given prefix with the line number
+ * to obtain a 'unique' identifier.
+ *
+ * \internal From boost documentation:
+ * The following piece of macro magic joins the two 
+ * arguments together, even when one of the arguments is
+ * itself a macro (see 16.3.1 in C++ standard).  The key
+ * is that macro expansion of macro arguments does not
+ * occur in CPPUNIT_JOIN2 but does in CPPUNIT_JOIN.
+ */
+#define CPPUNIT_JOIN( symbol1, symbol2 ) _CPPUNIT_DO_JOIN( symbol1, symbol2 )
+
+/// \internal
+#define _CPPUNIT_DO_JOIN( symbol1, symbol2 ) _CPPUNIT_DO_JOIN2( symbol1, symbol2 )
+
+/// \internal
+#define _CPPUNIT_DO_JOIN2( symbol1, symbol2 ) symbol1##symbol2
+
+/*! Adds the line number to the specified string to create a unique identifier.
+ * \param prefix Prefix added to the line number to create a unique identifier.
+ * \see CPPUNIT_TEST_SUITE_REGISTRATION for an example of usage.
+ */
+#define CPPUNIT_MAKE_UNIQUE_NAME( prefix ) CPPUNIT_JOIN( prefix, __LINE__ )
+
+/*! Defines wrap colunm for %CppUnit. Used by CompilerOuputter.
+ */
+#if !defined(CPPUNIT_WRAP_COLUMN)
+# define CPPUNIT_WRAP_COLUMN 79
+#endif
+
+#endif // CPPUNIT_PORTABILITY_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/Protector.h b/3rdParty/CppUnit/src/include/cppunit/Protector.h
new file mode 100644
index 0000000..d14e75f
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/Protector.h
@@ -0,0 +1,94 @@
+#ifndef CPPUNIT_PROTECTOR_H
+#define CPPUNIT_PROTECTOR_H
+
+#include <cppunit/SourceLine.h>
+
+CPPUNIT_NS_BEGIN
+
+class Exception;
+class Message;
+class ProtectorContext;
+class TestResult;
+
+
+class CPPUNIT_API Functor
+{
+public:
+  virtual ~Functor();
+
+  virtual bool operator()() const =0;
+};
+
+
+/*! \brief Protects one or more test case run.
+ *
+ * Protector are used to globably 'decorate' a test case. The most common
+ * usage of Protector is to catch exception that do not subclass std::exception,
+ * such as MFC CException class or Rogue Wave RWXMsg class, and capture the
+ * message associated to the exception. In fact, CppUnit capture message from
+ * Exception and std::exception using a Protector.
+ *
+ * Protector are chained. When you add a Protector using 
+ * TestResult::pushProtector(), your protector is in fact passed as a Functor
+ * to the first protector of the chain.
+ *
+ * TestCase protects call to setUp(), runTest() and tearDown() by calling
+ * TestResult::protect().
+ *
+ * Because the protector chain is handled by TestResult, a protector can be
+ * active for a single test, or a complete test run.
+ *
+ * Here are some possible usages:
+ * - run all test case in a separate thread and assumes the test failed if it
+ *   did not finish in a given time (infinite loop work around)
+ * - performance tracing : time only the runTest() time.
+ * \sa TestResult, TestCase, TestListener.
+ */
+class CPPUNIT_API Protector
+{
+public:
+  virtual ~Protector();
+  
+  virtual bool protect( const Functor &functor,
+                        const ProtectorContext &context ) =0;
+
+protected:
+  void reportError( const ProtectorContext &context,
+                    const Exception &error ) const;
+
+  void reportError( const ProtectorContext &context,
+                    const Message &message,
+                    const SourceLine &sourceLine = SourceLine() ) const;
+
+  void reportFailure( const ProtectorContext &context,
+                      const Exception &failure ) const;
+
+  Message actualMessage( const Message &message,
+                         const ProtectorContext &context ) const;
+};
+
+
+/*! \brief Scoped protector push to TestResult.
+ *
+ * Adds the specified Protector to the specified TestResult for the object
+ * life-time.
+ */
+class CPPUNIT_API ProtectorGuard
+{
+public:
+  /// Pushes the specified protector.
+  ProtectorGuard( TestResult *result,
+                  Protector *protector );
+
+  /// Pops the protector.
+  ~ProtectorGuard();
+
+private:
+  TestResult *m_result;
+};
+
+CPPUNIT_NS_END
+
+
+#endif // CPPUNIT_PROTECTOR_H
+
diff --git a/3rdParty/CppUnit/src/include/cppunit/SourceLine.h b/3rdParty/CppUnit/src/include/cppunit/SourceLine.h
new file mode 100644
index 0000000..f7a85df
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/SourceLine.h
@@ -0,0 +1,63 @@
+#ifndef CPPUNIT_SOURCELINE_H
+#define CPPUNIT_SOURCELINE_H
+
+#include <cppunit/Portability.h>
+#include <string>
+
+/*! \brief Constructs a SourceLine object initialized with the location where the macro is expanded.
+ * \ingroup CreatingNewAssertions
+ * \relates CppUnit::SourceLine
+ * Used to write your own assertion macros.
+ * \see Asserter for example of usage.
+ */
+#define CPPUNIT_SOURCELINE() CPPUNIT_NS::SourceLine( __FILE__, __LINE__ )
+
+
+CPPUNIT_NS_BEGIN
+
+
+/*! \brief Represents a source line location.
+ * \ingroup CreatingNewAssertions
+ * \ingroup BrowsingCollectedTestResult
+ *
+ * Used to capture the failure location in assertion.
+ * 
+ * Use the CPPUNIT_SOURCELINE() macro to construct that object. Typically used when
+ * writing an assertion macro in association with Asserter.
+ *
+ * \see Asserter.
+ */
+class CPPUNIT_API SourceLine
+{
+public:
+  SourceLine();
+
+  // Ensure thread-safe copy by detaching the string buffer.
+  SourceLine( const SourceLine &other );
+
+  SourceLine( const std::string &fileName,
+              int lineNumber );
+
+  SourceLine &operator =( const SourceLine &other );
+
+  /// Destructor.
+  virtual ~SourceLine();
+
+  bool isValid() const;
+
+  int lineNumber() const;
+
+  std::string fileName() const;
+
+  bool operator ==( const SourceLine &other ) const;
+  bool operator !=( const SourceLine &other ) const;
+
+private:
+  std::string m_fileName;
+  int m_lineNumber;
+};
+
+
+CPPUNIT_NS_END
+
+#endif  // CPPUNIT_SOURCELINE_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/SynchronizedObject.h b/3rdParty/CppUnit/src/include/cppunit/SynchronizedObject.h
new file mode 100644
index 0000000..0f7d094
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/SynchronizedObject.h
@@ -0,0 +1,80 @@
+#ifndef CPPUNIT_SYNCHRONIZEDOBJECT_H
+#define CPPUNIT_SYNCHRONIZEDOBJECT_H
+
+#include <cppunit/Portability.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+/*! \brief Base class for synchronized object.
+ *
+ * Synchronized object are object which members are used concurrently by mutiple
+ * threads.
+ *
+ * This class define the class SynchronizationObject which must be subclassed
+ * to implement an actual lock.
+ *
+ * Each instance of this class holds a pointer on a lock object.
+ *
+ * See src/msvc6/MfcSynchronizedObject.h for an example.
+ */
+class CPPUNIT_API SynchronizedObject
+{
+public:
+  /*! \brief Abstract synchronization object (mutex)
+   */
+  class SynchronizationObject
+  {
+    public:
+      SynchronizationObject() {}
+      virtual ~SynchronizationObject() {}
+
+      virtual void lock() {}
+      virtual void unlock() {}
+  };
+
+  /*! Constructs a SynchronizedObject object.
+   */
+  SynchronizedObject( SynchronizationObject *syncObject =0 );
+
+  /// Destructor.
+  virtual ~SynchronizedObject();
+
+protected:
+  /*! \brief Locks a synchronization object in the current scope.
+   */
+  class ExclusiveZone
+  {
+    SynchronizationObject *m_syncObject;
+
+  public:
+    ExclusiveZone( SynchronizationObject *syncObject ) 
+        : m_syncObject( syncObject ) 
+    { 
+      m_syncObject->lock(); 
+    }
+
+    ~ExclusiveZone() 
+    { 
+      m_syncObject->unlock (); 
+    }
+  };
+
+  virtual void setSynchronizationObject( SynchronizationObject *syncObject );
+
+protected:
+  SynchronizationObject *m_syncObject;
+
+private:
+  /// Prevents the use of the copy constructor.
+  SynchronizedObject( const SynchronizedObject &copy );
+
+  /// Prevents the use of the copy operator.
+  void operator =( const SynchronizedObject &copy );
+};
+
+
+CPPUNIT_NS_END
+
+#endif  // CPPUNIT_SYNCHRONIZEDOBJECT_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/Test.h b/3rdParty/CppUnit/src/include/cppunit/Test.h
new file mode 100644
index 0000000..a56be0f
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/Test.h
@@ -0,0 +1,117 @@
+#ifndef CPPUNIT_TEST_H
+#define CPPUNIT_TEST_H
+
+#include <cppunit/Portability.h>
+#include <string>
+
+CPPUNIT_NS_BEGIN
+
+
+class TestResult;
+class TestPath;
+
+/*! \brief Base class for all test objects.
+ * \ingroup BrowsingCollectedTestResult
+ *
+ * All test objects should be a subclass of Test.  Some test objects,
+ * TestCase for example, represent one individual test.  Other test
+ * objects, such as TestSuite, are comprised of several tests.  
+ *
+ * When a Test is run, the result is collected by a TestResult object.
+ *
+ * \see TestCase
+ * \see TestSuite
+ */
+class CPPUNIT_API Test
+{
+public:
+  virtual ~Test() {};
+
+  /*! \brief Run the test, collecting results.
+   */
+  virtual void run( TestResult *result ) =0;
+
+  /*! \brief Return the number of test cases invoked by run().
+   *
+   * The base unit of testing is the class TestCase.  This
+   * method returns the number of TestCase objects invoked by
+   * the run() method.
+   */
+  virtual int countTestCases () const =0;
+
+  /*! \brief Returns the number of direct child of the test.
+   */
+  virtual int getChildTestCount() const =0;
+
+  /*! \brief Returns the child test of the specified index.
+   *
+   * This method test if the index is valid, then call doGetChildTestAt() if 
+   * the index is valid. Otherwise std::out_of_range exception is thrown.
+   *
+   * You should override doGetChildTestAt() method.
+   * 
+   * \param index Zero based index of the child test to return.
+   * \return Pointer on the test. Never \c NULL.
+   * \exception std::out_of_range is \a index is < 0 or >= getChildTestCount().
+   */
+  virtual Test *getChildTestAt( int index ) const;
+
+  /*! \brief Returns the test name.
+   * 
+   * Each test has a name.  This name may be used to find the
+   * test in a suite or registry of tests.
+   */
+  virtual std::string getName () const =0;
+
+  /*! \brief Finds the test with the specified name and its parents test.
+   * \param testName Name of the test to find.
+   * \param testPath If the test is found, then all the tests traversed to access
+   *                 \a test are added to \a testPath, including \c this and \a test.
+   * \return \c true if a test with the specified name is found, \c false otherwise.
+   */
+  virtual bool findTestPath( const std::string &testName,
+                             TestPath &testPath ) const;
+
+  /*! \brief Finds the specified test and its parents test.
+   * \param test Test to find.
+   * \param testPath If the test is found, then all the tests traversed to access
+   *                 \a test are added to \a testPath, including \c this and \a test.
+   * \return \c true if the specified test is found, \c false otherwise.
+   */
+  virtual bool findTestPath( const Test *test,
+                             TestPath &testPath ) const;
+
+  /*! \brief Finds the test with the specified name in the hierarchy.
+   * \param testName Name of the test to find.
+   * \return Pointer on the first test found that is named \a testName. Never \c NULL.
+   * \exception std::invalid_argument if no test named \a testName is found.
+   */
+  virtual Test *findTest( const std::string &testName ) const;
+
+  /*! \brief Resolved the specified test path with this test acting as 'root'.
+   * \param testPath Test path string to resolve.
+   * \return Resolved TestPath. 
+   * \exception std::invalid_argument if \a testPath could not be resolved.
+   * \see TestPath.
+   */
+  virtual TestPath resolveTestPath( const std::string &testPath ) const;
+
+protected:
+  /*! Throws an exception if the specified index is invalid.
+   * \param index Zero base index of a child test.
+   * \exception std::out_of_range is \a index is < 0 or >= getChildTestCount().
+   */
+  virtual void checkIsValidIndex( int index ) const;
+
+  /*! \brief Returns the child test of the specified valid index.
+   * \param index Zero based valid index of the child test to return.
+   * \return Pointer on the test. Never \c NULL.
+   */
+  virtual Test *doGetChildTestAt( int index ) const =0;
+};
+
+
+CPPUNIT_NS_END
+
+#endif // CPPUNIT_TEST_H
+
diff --git a/3rdParty/CppUnit/src/include/cppunit/TestAssert.h b/3rdParty/CppUnit/src/include/cppunit/TestAssert.h
new file mode 100644
index 0000000..f74797b
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/TestAssert.h
@@ -0,0 +1,428 @@
+#ifndef CPPUNIT_TESTASSERT_H
+#define CPPUNIT_TESTASSERT_H
+
+#include <cppunit/Portability.h>
+#include <cppunit/Exception.h>
+#include <cppunit/Asserter.h>
+#include <cppunit/portability/Stream.h>
+#include <stdio.h>
+#include <float.h> // For struct assertion_traits<double>
+
+
+CPPUNIT_NS_BEGIN
+
+
+/*! \brief Traits used by CPPUNIT_ASSERT_EQUAL().
+ *
+ * Here is an example of specialising these traits: 
+ *
+ * \code
+ * template<>
+ * struct assertion_traits<std::string>   // specialization for the std::string type
+ * {
+ *   static bool equal( const std::string& x, const std::string& y )
+ *   {
+ *     return x == y;
+ *   }
+ * 
+ *   static std::string toString( const std::string& x )
+ *   {
+ *     std::string text = '"' + x + '"';    // adds quote around the string to see whitespace
+ *     OStringStream ost;
+ *     ost << text;
+ *     return ost.str();
+ *   }
+ * };
+ * \endcode
+ */
+template <class T>
+struct assertion_traits 
+{  
+    static bool equal( const T& x, const T& y )
+    {
+        return x == y;
+    }
+
+    static std::string toString( const T& x )
+    {
+        OStringStream ost;
+        ost << x;
+        return ost.str();
+    }
+};
+
+
+/*! \brief Traits used by CPPUNIT_ASSERT_DOUBLES_EQUAL(). 
+ * 
+ * This specialisation from @c struct @c assertion_traits<> ensures that 
+ * doubles are converted in full, instead of being rounded to the default 
+ * 6 digits of precision. Use the system defined ISO C99 macro DBL_DIG 
+ * within float.h is available to define the maximum precision, otherwise
+ * use the hard-coded maximum precision of 15.
+ */
+template <>
+struct assertion_traits<double>
+{  
+    static bool equal( double x, double y )
+    {
+        return x == y;
+    }
+
+    static std::string toString( double x )
+    {
+#ifdef DBL_DIG
+       const int precision = DBL_DIG;
+#else
+       const int precision = 15;
+#endif  // #ifdef DBL_DIG
+       char buffer[128];
+#ifdef __STDC_SECURE_LIB__ // Use secure version with visual studio 2005 to avoid warning.
+       sprintf_s(buffer, sizeof(buffer), "%.*g", precision, x); 
+#else	
+       sprintf(buffer, "%.*g", precision, x); 
+#endif
+       return buffer;
+    }
+};
+
+
+/*! \brief (Implementation) Asserts that two objects of the same type are equals.
+ * Use CPPUNIT_ASSERT_EQUAL instead of this function.
+ * \sa assertion_traits, Asserter::failNotEqual().
+ */
+template <class T>
+void assertEquals( const T& expected,
+                   const T& actual,
+                   SourceLine sourceLine,
+                   const std::string &message )
+{
+  if ( !assertion_traits<T>::equal(expected,actual) ) // lazy toString conversion...
+  {
+    Asserter::failNotEqual( assertion_traits<T>::toString(expected),
+                            assertion_traits<T>::toString(actual),
+                            sourceLine,
+                            message );
+  }
+}
+
+
+/*! \brief (Implementation) Asserts that two double are equals given a tolerance.
+ * Use CPPUNIT_ASSERT_DOUBLES_EQUAL instead of this function.
+ * \sa Asserter::failNotEqual().
+ * \sa CPPUNIT_ASSERT_DOUBLES_EQUAL for detailed semantic of the assertion.
+ */
+void CPPUNIT_API assertDoubleEquals( double expected,
+                                     double actual,
+                                     double delta,
+                                     SourceLine sourceLine, 
+                                     const std::string &message );
+
+
+/* A set of macros which allow us to get the line number
+ * and file name at the point of an error.
+ * Just goes to show that preprocessors do have some
+ * redeeming qualities.
+ */
+#if CPPUNIT_HAVE_CPP_SOURCE_ANNOTATION
+/** Assertions that a condition is \c true.
+ * \ingroup Assertions
+ */
+#define CPPUNIT_ASSERT(condition)                                                 \
+  ( CPPUNIT_NS::Asserter::failIf( !(condition),                                   \
+                                 CPPUNIT_NS::Message( "assertion failed",         \
+                                                      "Expression: " #condition), \
+                                 CPPUNIT_SOURCELINE() ) )
+#else
+#define CPPUNIT_ASSERT(condition)                                            \
+  ( CPPUNIT_NS::Asserter::failIf( !(condition),                              \
+                                  CPPUNIT_NS::Message( "assertion failed" ), \
+                                  CPPUNIT_SOURCELINE() ) )
+#endif
+
+/** Assertion with a user specified message.
+ * \ingroup Assertions
+ * \param message Message reported in diagnostic if \a condition evaluates
+ *                to \c false.
+ * \param condition If this condition evaluates to \c false then the
+ *                  test failed.
+ */
+#define CPPUNIT_ASSERT_MESSAGE(message,condition)                          \
+  ( CPPUNIT_NS::Asserter::failIf( !(condition),                            \
+                                  CPPUNIT_NS::Message( "assertion failed", \
+                                                       "Expression: "      \
+                                                       #condition,         \
+                                                       message ),          \
+                                  CPPUNIT_SOURCELINE() ) )
+
+/** Fails with the specified message.
+ * \ingroup Assertions
+ * \param message Message reported in diagnostic.
+ */
+#define CPPUNIT_FAIL( message )                                         \
+  ( CPPUNIT_NS::Asserter::fail( CPPUNIT_NS::Message( "forced failure",  \
+                                                     message ),         \
+                                CPPUNIT_SOURCELINE() ) )
+
+#ifdef CPPUNIT_ENABLE_SOURCELINE_DEPRECATED
+/// Generalized macro for primitive value comparisons
+#define CPPUNIT_ASSERT_EQUAL(expected,actual)                     \
+  ( CPPUNIT_NS::assertEquals( (expected),             \
+                              (actual),               \
+                              __LINE__, __FILE__ ) )
+#else
+/** Asserts that two values are equals.
+ * \ingroup Assertions
+ *
+ * Equality and string representation can be defined with
+ * an appropriate CppUnit::assertion_traits class.
+ *
+ * A diagnostic is printed if actual and expected values disagree.
+ *
+ * Requirement for \a expected and \a actual parameters:
+ * - They are exactly of the same type
+ * - They are serializable into a std::strstream using operator <<.
+ * - They can be compared using operator ==. 
+ *
+ * The last two requirements (serialization and comparison) can be
+ * removed by specializing the CppUnit::assertion_traits.
+ */
+#define CPPUNIT_ASSERT_EQUAL(expected,actual)          \
+  ( CPPUNIT_NS::assertEquals( (expected),              \
+                              (actual),                \
+                              CPPUNIT_SOURCELINE(),    \
+                              "" ) )
+
+/** Asserts that two values are equals, provides additional message on failure.
+ * \ingroup Assertions
+ *
+ * Equality and string representation can be defined with
+ * an appropriate assertion_traits class.
+ *
+ * A diagnostic is printed if actual and expected values disagree.
+ * The message is printed in addition to the expected and actual value
+ * to provide additional information.
+ *
+ * Requirement for \a expected and \a actual parameters:
+ * - They are exactly of the same type
+ * - They are serializable into a std::strstream using operator <<.
+ * - They can be compared using operator ==. 
+ *
+ * The last two requirements (serialization and comparison) can be
+ * removed by specializing the CppUnit::assertion_traits.
+ */
+#define CPPUNIT_ASSERT_EQUAL_MESSAGE(message,expected,actual)      \
+  ( CPPUNIT_NS::assertEquals( (expected),              \
+                              (actual),                \
+                              CPPUNIT_SOURCELINE(),    \
+                              (message) ) )
+#endif
+
+/*! \brief Macro for primitive double value comparisons. 
+ * \ingroup Assertions
+ *
+ * The assertion pass if both expected and actual are finite and
+ * \c fabs( \c expected - \c actual ) <= \c delta.
+ * If either \c expected or actual are infinite (+/- inf), the 
+ * assertion pass if \c expected == \c actual.
+ * If either \c expected or \c actual is a NaN (not a number), then
+ * the assertion fails.
+ */
+#define CPPUNIT_ASSERT_DOUBLES_EQUAL(expected,actual,delta)        \
+  ( CPPUNIT_NS::assertDoubleEquals( (expected),            \
+                                    (actual),              \
+                                    (delta),               \
+                                    CPPUNIT_SOURCELINE(),  \
+                                    "" ) )
+
+
+/*! \brief Macro for primitive double value comparisons, setting a 
+ * user-supplied message in case of failure. 
+ * \ingroup Assertions
+ * \sa CPPUNIT_ASSERT_DOUBLES_EQUAL for detailed semantic of the assertion.
+ */
+#define CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE(message,expected,actual,delta)  \
+  ( CPPUNIT_NS::assertDoubleEquals( (expected),            \
+                                    (actual),              \
+                                    (delta),               \
+                                    CPPUNIT_SOURCELINE(),  \
+                                    (message) ) )
+
+
+/** Asserts that the given expression throws an exception of the specified type. 
+ * \ingroup Assertions
+ * Example of usage:
+ * \code
+ *   std::vector<int> v;
+ *  CPPUNIT_ASSERT_THROW( v.at( 50 ), std::out_of_range );
+ * \endcode
+ */
+# define CPPUNIT_ASSERT_THROW( expression, ExceptionType )              \
+   CPPUNIT_ASSERT_THROW_MESSAGE( CPPUNIT_NS::AdditionalMessage(),       \
+                                 expression,                            \
+                                 ExceptionType )
+
+
+// implementation detail
+#if CPPUNIT_USE_TYPEINFO_NAME
+#define CPPUNIT_EXTRACT_EXCEPTION_TYPE_( exception, no_rtti_message ) \
+   CPPUNIT_NS::TypeInfoHelper::getClassName( typeid(exception) )
+#else
+#define CPPUNIT_EXTRACT_EXCEPTION_TYPE_( exception, no_rtti_message ) \
+   std::string( no_rtti_message )
+#endif // CPPUNIT_USE_TYPEINFO_NAME
+
+// implementation detail
+#define CPPUNIT_GET_PARAMETER_STRING( parameter ) #parameter
+
+/** Asserts that the given expression throws an exception of the specified type, 
+ * setting a user supplied message in case of failure. 
+ * \ingroup Assertions
+ * Example of usage:
+ * \code
+ *   std::vector<int> v;
+ *  CPPUNIT_ASSERT_THROW_MESSAGE( "- std::vector<int> v;", v.at( 50 ), std::out_of_range );
+ * \endcode
+ */
+# define CPPUNIT_ASSERT_THROW_MESSAGE( message, expression, ExceptionType )   \
+   do {                                                                       \
+      bool cpputCorrectExceptionThrown_ = false;                              \
+      CPPUNIT_NS::Message cpputMsg_( "expected exception not thrown" );       \
+      cpputMsg_.addDetail( message );                                         \
+      cpputMsg_.addDetail( "Expected: "                                       \
+                           CPPUNIT_GET_PARAMETER_STRING( ExceptionType ) );   \
+                                                                              \
+      try {                                                                   \
+         expression;                                                          \
+      } catch ( const ExceptionType & ) {                                     \
+         cpputCorrectExceptionThrown_ = true;                                 \
+      } catch ( const std::exception &e) {                                    \
+         cpputMsg_.addDetail( "Actual  : " +                                  \
+                              CPPUNIT_EXTRACT_EXCEPTION_TYPE_( e,             \
+                                          "std::exception or derived") );     \
+         cpputMsg_.addDetail( std::string("What()  : ") + e.what() );         \
+      } catch ( ... ) {                                                       \
+         cpputMsg_.addDetail( "Actual  : unknown.");                          \
+      }                                                                       \
+                                                                              \
+      if ( cpputCorrectExceptionThrown_ )                                     \
+         break;                                                               \
+                                                                              \
+      CPPUNIT_NS::Asserter::fail( cpputMsg_,                                  \
+                                  CPPUNIT_SOURCELINE() );                     \
+   } while ( false )
+
+
+/** Asserts that the given expression does not throw any exceptions.
+ * \ingroup Assertions
+ * Example of usage:
+ * \code
+ *   std::vector<int> v;
+ *   v.push_back( 10 );
+ *  CPPUNIT_ASSERT_NO_THROW( v.at( 0 ) );
+ * \endcode
+ */
+# define CPPUNIT_ASSERT_NO_THROW( expression )                             \
+   CPPUNIT_ASSERT_NO_THROW_MESSAGE( CPPUNIT_NS::AdditionalMessage(),       \
+                                    expression )
+
+
+/** Asserts that the given expression does not throw any exceptions, 
+ * setting a user supplied message in case of failure. 
+ * \ingroup Assertions
+ * Example of usage:
+ * \code
+ *   std::vector<int> v;
+ *   v.push_back( 10 );
+ *  CPPUNIT_ASSERT_NO_THROW( "std::vector<int> v;", v.at( 0 ) );
+ * \endcode
+ */
+# define CPPUNIT_ASSERT_NO_THROW_MESSAGE( message, expression )               \
+   do {                                                                       \
+      CPPUNIT_NS::Message cpputMsg_( "unexpected exception caught" );         \
+      cpputMsg_.addDetail( message );                                         \
+                                                                              \
+      try {                                                                   \
+         expression;                                                          \
+      } catch ( const std::exception &e ) {                                   \
+         cpputMsg_.addDetail( "Caught: " +                                    \
+                              CPPUNIT_EXTRACT_EXCEPTION_TYPE_( e,             \
+                                          "std::exception or derived" ) );    \
+         cpputMsg_.addDetail( std::string("What(): ") + e.what() );           \
+         CPPUNIT_NS::Asserter::fail( cpputMsg_,                               \
+                                     CPPUNIT_SOURCELINE() );                  \
+      } catch ( ... ) {                                                       \
+         cpputMsg_.addDetail( "Caught: unknown." );                           \
+         CPPUNIT_NS::Asserter::fail( cpputMsg_,                               \
+                                     CPPUNIT_SOURCELINE() );                  \
+      }                                                                       \
+   } while ( false )
+
+
+/** Asserts that an assertion fail.
+ * \ingroup Assertions
+ * Use to test assertions.
+ * Example of usage:
+ * \code
+ *   CPPUNIT_ASSERT_ASSERTION_FAIL( CPPUNIT_ASSERT( 1 == 2 ) );
+ * \endcode
+ */
+# define CPPUNIT_ASSERT_ASSERTION_FAIL( assertion )                 \
+   CPPUNIT_ASSERT_THROW( assertion, CPPUNIT_NS::Exception )
+
+
+/** Asserts that an assertion fail, with a user-supplied message in 
+ * case of error.
+ * \ingroup Assertions
+ * Use to test assertions.
+ * Example of usage:
+ * \code
+ *   CPPUNIT_ASSERT_ASSERTION_FAIL_MESSAGE( "1 == 2", CPPUNIT_ASSERT( 1 == 2 ) );
+ * \endcode
+ */
+# define CPPUNIT_ASSERT_ASSERTION_FAIL_MESSAGE( message, assertion )    \
+   CPPUNIT_ASSERT_THROW_MESSAGE( message, assertion, CPPUNIT_NS::Exception )
+
+
+/** Asserts that an assertion pass.
+ * \ingroup Assertions
+ * Use to test assertions.
+ * Example of usage:
+ * \code
+ *   CPPUNIT_ASSERT_ASSERTION_PASS( CPPUNIT_ASSERT( 1 == 1 ) );
+ * \endcode
+ */
+# define CPPUNIT_ASSERT_ASSERTION_PASS( assertion )                 \
+   CPPUNIT_ASSERT_NO_THROW( assertion )
+
+
+/** Asserts that an assertion pass, with a user-supplied message in 
+ * case of failure. 
+ * \ingroup Assertions
+ * Use to test assertions.
+ * Example of usage:
+ * \code
+ *   CPPUNIT_ASSERT_ASSERTION_PASS_MESSAGE( "1 != 1", CPPUNIT_ASSERT( 1 == 1 ) );
+ * \endcode
+ */
+# define CPPUNIT_ASSERT_ASSERTION_PASS_MESSAGE( message, assertion )    \
+   CPPUNIT_ASSERT_NO_THROW_MESSAGE( message, assertion )
+
+
+
+
+// Backwards compatibility
+
+#if CPPUNIT_ENABLE_NAKED_ASSERT
+
+#undef assert
+#define assert(c)                 CPPUNIT_ASSERT(c)
+#define assertEqual(e,a)          CPPUNIT_ASSERT_EQUAL(e,a)
+#define assertDoublesEqual(e,a,d) CPPUNIT_ASSERT_DOUBLES_EQUAL(e,a,d)
+#define assertLongsEqual(e,a)     CPPUNIT_ASSERT_EQUAL(e,a)
+
+#endif
+
+
+CPPUNIT_NS_END
+
+#endif  // CPPUNIT_TESTASSERT_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/TestCaller.h b/3rdParty/CppUnit/src/include/cppunit/TestCaller.h
new file mode 100644
index 0000000..dc4d82e
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/TestCaller.h
@@ -0,0 +1,204 @@
+#ifndef CPPUNIT_TESTCALLER_H    // -*- C++ -*-
+#define CPPUNIT_TESTCALLER_H
+
+#include <cppunit/Exception.h>
+#include <cppunit/TestCase.h>
+
+
+#if CPPUNIT_USE_TYPEINFO_NAME
+#  include <cppunit/extensions/TypeInfoHelper.h>
+#endif
+
+
+CPPUNIT_NS_BEGIN
+
+#if 0
+/*! \brief Marker class indicating that no exception is expected by TestCaller.
+ * This class is an implementation detail. You should never use this class directly.
+ */
+class CPPUNIT_API NoExceptionExpected
+{
+private:
+  //! Prevent class instantiation.
+  NoExceptionExpected();
+};
+
+
+/*! \brief (Implementation) Traits used by TestCaller to expect an exception.
+ *
+ * This class is an implementation detail. You should never use this class directly.
+ */
+template<class ExceptionType>
+struct ExpectedExceptionTraits
+{
+  static void expectedException()
+  {
+#if CPPUNIT_USE_TYPEINFO_NAME
+    throw Exception( Message(
+                         "expected exception not thrown",
+                         "Expected exception type: " + 
+                           TypeInfoHelper::getClassName( typeid( ExceptionType ) ) ) );
+#else
+    throw Exception( "expected exception not thrown" );
+#endif
+  }
+};
+
+
+/*! \brief (Implementation) Traits specialization used by TestCaller to 
+ * expect no exception.
+ *
+ * This class is an implementation detail. You should never use this class directly.
+ */
+template<>
+struct ExpectedExceptionTraits<NoExceptionExpected>
+{
+  static void expectedException()
+  {
+  }
+};
+
+
+#endif
+
+//*** FIXME: rework this when class Fixture is implemented. ***//
+
+
+/*! \brief Generate a test case from a fixture method.
+ * \ingroup WritingTestFixture
+ *
+ * A test caller provides access to a test case method 
+ * on a test fixture class.  Test callers are useful when 
+ * you want to run an individual test or add it to a 
+ * suite.
+ * Test Callers invoke only one Test (i.e. test method) on one 
+ * Fixture of a TestFixture.
+ * 
+ * Here is an example:
+ * \code
+ * class MathTest : public CppUnit::TestFixture {
+ *         ...
+ *     public:
+ *         void         setUp();
+ *         void         tearDown();
+ *
+ *         void         testAdd();
+ *         void         testSubtract();
+ * };
+ *
+ * CppUnit::Test *MathTest::suite() {
+ *     CppUnit::TestSuite *suite = new CppUnit::TestSuite;
+ *
+ *     suite->addTest( new CppUnit::TestCaller<MathTest>( "testAdd", testAdd ) );
+ *     return suite;
+ * }
+ * \endcode
+ *
+ * You can use a TestCaller to bind any test method on a TestFixture
+ * class, as long as it accepts void and returns void.
+ * 
+ * \see TestCase
+ */
+
+template <class Fixture>
+class TestCaller : public TestCase
+{ 
+  typedef void (Fixture::*TestMethod)();
+    
+public:
+  /*!
+   * Constructor for TestCaller. This constructor builds a new Fixture
+   * instance owned by the TestCaller.
+   * \param name name of this TestCaller
+   * \param test the method this TestCaller calls in runTest()
+   */
+  TestCaller( std::string name, TestMethod test ) :
+	    TestCase( name ), 
+	    m_ownFixture( true ),
+	    m_fixture( new Fixture() ),
+	    m_test( test )
+  {
+  }
+
+  /*!
+   * Constructor for TestCaller. 
+   * This constructor does not create a new Fixture instance but accepts
+   * an existing one as parameter. The TestCaller will not own the
+   * Fixture object.
+   * \param name name of this TestCaller
+   * \param test the method this TestCaller calls in runTest()
+   * \param fixture the Fixture to invoke the test method on.
+   */
+  TestCaller(std::string name, TestMethod test, Fixture& fixture) :
+	    TestCase( name ), 
+	    m_ownFixture( false ),
+	    m_fixture( &fixture ),
+	    m_test( test )
+  {
+  }
+    
+  /*!
+   * Constructor for TestCaller. 
+   * This constructor does not create a new Fixture instance but accepts
+   * an existing one as parameter. The TestCaller will own the
+   * Fixture object and delete it in its destructor.
+   * \param name name of this TestCaller
+   * \param test the method this TestCaller calls in runTest()
+   * \param fixture the Fixture to invoke the test method on.
+   */
+  TestCaller(std::string name, TestMethod test, Fixture* fixture) :
+	    TestCase( name ), 
+	    m_ownFixture( true ),
+	    m_fixture( fixture ),
+	    m_test( test )
+  {
+  }
+    
+  ~TestCaller() 
+  {
+    if (m_ownFixture)
+      delete m_fixture;
+  }
+
+  void runTest()
+  { 
+//	  try {
+	    (m_fixture->*m_test)();
+//	  }
+//	  catch ( ExpectedException & ) {
+//	    return;
+//	  }
+
+//  	ExpectedExceptionTraits<ExpectedException>::expectedException();
+  }  
+
+  void setUp()
+  { 
+  	m_fixture->setUp (); 
+  }
+
+  void tearDown()
+  { 
+	  m_fixture->tearDown (); 
+  }
+
+  std::string toString() const
+  { 
+  	return "TestCaller " + getName(); 
+  }
+
+private: 
+  TestCaller( const TestCaller &other ); 
+  TestCaller &operator =( const TestCaller &other );
+
+private:
+  bool m_ownFixture;
+  Fixture *m_fixture;
+  TestMethod m_test;
+};
+
+
+
+CPPUNIT_NS_END
+
+#endif // CPPUNIT_TESTCALLER_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/TestCase.h b/3rdParty/CppUnit/src/include/cppunit/TestCase.h
new file mode 100644
index 0000000..d4b7a46
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/TestCase.h
@@ -0,0 +1,55 @@
+#ifndef CPPUNIT_TESTCASE_H
+#define CPPUNIT_TESTCASE_H
+
+#include <cppunit/Portability.h>
+#include <cppunit/TestLeaf.h>
+#include <cppunit/TestAssert.h>
+#include <cppunit/TestFixture.h>
+#include <string>
+
+
+CPPUNIT_NS_BEGIN
+
+
+class TestResult;
+
+
+/*! \brief A single test object.
+ *
+ * This class is used to implement a simple test case: define a subclass
+ * that overrides the runTest method.
+ *
+ * You don't usually need to use that class, but TestFixture and TestCaller instead.
+ *
+ * You are expected to subclass TestCase is you need to write a class similiar
+ * to TestCaller.
+ */
+class CPPUNIT_API TestCase : public TestLeaf,
+                             public TestFixture
+{
+public:
+
+    TestCase( const std::string &name );
+
+    TestCase();
+
+    ~TestCase();
+    
+    virtual void run(TestResult *result);
+
+    std::string getName() const;
+
+    //! FIXME: this should probably be pure virtual.
+    virtual void runTest();
+    
+private:
+    TestCase( const TestCase &other ); 
+    TestCase &operator=( const TestCase &other ); 
+    
+private:
+    const std::string m_name;
+};
+
+CPPUNIT_NS_END
+
+#endif // CPPUNIT_TESTCASE_H 
diff --git a/3rdParty/CppUnit/src/include/cppunit/TestComposite.h b/3rdParty/CppUnit/src/include/cppunit/TestComposite.h
new file mode 100644
index 0000000..0ded95f
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/TestComposite.h
@@ -0,0 +1,45 @@
+#ifndef CPPUNIT_TESTCOMPSITE_H    // -*- C++ -*-
+#define CPPUNIT_TESTCOMPSITE_H
+
+#include <cppunit/Test.h>
+#include <string>
+
+CPPUNIT_NS_BEGIN
+
+
+/*! \brief A Composite of Tests.
+ *
+ * Base class for all test composites. Subclass this class if you need to implement
+ * a custom TestSuite.
+ * 
+ * \see Test, TestSuite.
+ */
+class CPPUNIT_API TestComposite : public Test
+{
+public:
+  TestComposite( const std::string &name = "" );
+
+  ~TestComposite();
+
+  void run( TestResult *result );
+
+  int countTestCases() const;
+  
+  std::string getName() const;
+
+private:
+  TestComposite( const TestComposite &other );
+  TestComposite &operator =( const TestComposite &other ); 
+
+  virtual void doStartSuite( TestResult *controller );
+  virtual void doRunChildTests( TestResult *controller );
+  virtual void doEndSuite( TestResult *controller );
+
+private:
+  const std::string m_name;
+};
+
+
+CPPUNIT_NS_END
+
+#endif // CPPUNIT_TESTCOMPSITE_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/TestFailure.h b/3rdParty/CppUnit/src/include/cppunit/TestFailure.h
new file mode 100644
index 0000000..6419979
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/TestFailure.h
@@ -0,0 +1,58 @@
+#ifndef CPPUNIT_TESTFAILURE_H    // -*- C++ -*-
+#define CPPUNIT_TESTFAILURE_H
+
+#include <cppunit/Portability.h>
+#include <string>
+
+CPPUNIT_NS_BEGIN
+
+
+class Exception;
+class SourceLine;
+class Test;
+
+
+/*! \brief Record of a failed Test execution.
+ * \ingroup BrowsingCollectedTestResult
+ *
+ * A TestFailure collects a failed test together with
+ * the caught exception.
+ *
+ * TestFailure assumes lifetime control for any exception
+ * passed to it.
+ */
+class CPPUNIT_API TestFailure 
+{
+public:
+  TestFailure( Test *failedTest,
+               Exception *thrownException,
+               bool isError );
+
+  virtual ~TestFailure ();
+
+  virtual Test *failedTest() const;
+
+  virtual Exception *thrownException() const;
+
+  virtual SourceLine sourceLine() const;
+
+  virtual bool isError() const;
+
+  virtual std::string failedTestName() const;
+
+  virtual TestFailure *clone() const;
+
+protected:
+  Test *m_failedTest;
+  Exception *m_thrownException;
+  bool m_isError;
+
+private: 
+  TestFailure( const TestFailure &other ); 
+  TestFailure &operator =( const TestFailure& other ); 
+};
+
+
+CPPUNIT_NS_END
+
+#endif // CPPUNIT_TESTFAILURE_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/TestFixture.h b/3rdParty/CppUnit/src/include/cppunit/TestFixture.h
new file mode 100644
index 0000000..1223adb
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/TestFixture.h
@@ -0,0 +1,99 @@
+#ifndef CPPUNIT_TESTFIXTURE_H    // -*- C++ -*-
+#define CPPUNIT_TESTFIXTURE_H
+
+#include <cppunit/Portability.h>
+
+CPPUNIT_NS_BEGIN
+
+
+/*! \brief Wraps a test case with setUp and tearDown methods.
+ * \ingroup WritingTestFixture
+ *
+ * A TestFixture is used to provide a common environment for a set
+ * of test cases.
+ *
+ * To define a test fixture, do the following:
+ * - implement a subclass of TestCase 
+ * - the fixture is defined by instance variables 
+ * - initialize the fixture state by overriding setUp
+ *   (i.e. construct the instance variables of the fixture)
+ * - clean-up after a test by overriding tearDown.
+ *
+ * Each test runs in its own fixture so there
+ * can be no side effects among test runs.
+ * Here is an example:
+ * 
+ * \code
+ * class MathTest : public CppUnit::TestFixture {
+ * protected:
+ *   int m_value1, m_value2;
+ *
+ * public:
+ *   MathTest() {}
+ *
+ *   void setUp () {
+ *     m_value1 = 2;
+ *     m_value2 = 3;
+ *   }
+ * }
+ * \endcode
+ *
+ * For each test implement a method which interacts
+ * with the fixture. Verify the expected results with assertions specified
+ * by calling CPPUNIT_ASSERT on the expression you want to test:
+ * 
+ * \code
+ * public: 
+ *   void testAdd () {
+ *     int result = m_value1 + m_value2;
+ *     CPPUNIT_ASSERT( result == 5 );
+ *   }
+ * \endcode
+ * 
+ * Once the methods are defined you can run them. To do this, use
+ * a TestCaller.
+ *
+ * \code
+ * CppUnit::Test *test = new CppUnit::TestCaller<MathTest>( "testAdd", 
+ *                                                          &MathTest::testAdd );
+ * test->run();
+ * \endcode
+ *
+ *
+ * The tests to be run can be collected into a TestSuite. 
+ * 
+ * \code
+ * public: 
+ *   static CppUnit::TestSuite *MathTest::suite () {
+ *      CppUnit::TestSuite *suiteOfTests = new CppUnit::TestSuite;
+ *      suiteOfTests->addTest(new CppUnit::TestCaller<MathTest>(
+ *                              "testAdd", &MathTest::testAdd));
+ *      suiteOfTests->addTest(new CppUnit::TestCaller<MathTest>(
+ *                              "testDivideByZero", &MathTest::testDivideByZero));
+ *      return suiteOfTests;
+ *  }
+ * \endcode
+ * 
+ * A set of macros have been created for convenience. They are located in HelperMacros.h.
+ *
+ * \see TestResult, TestSuite, TestCaller,
+ * \see CPPUNIT_TEST_SUB_SUITE, CPPUNIT_TEST, CPPUNIT_TEST_SUITE_END, 
+ * \see CPPUNIT_TEST_SUITE_REGISTRATION, CPPUNIT_TEST_EXCEPTION, CPPUNIT_TEST_FAIL.
+ */
+class CPPUNIT_API TestFixture
+{
+public:
+  virtual ~TestFixture() {};
+
+  //! \brief Set up context before running a test.
+  virtual void setUp() {};
+
+  //! Clean up after the test run.
+  virtual void tearDown() {};
+};
+
+
+CPPUNIT_NS_END
+
+
+#endif
diff --git a/3rdParty/CppUnit/src/include/cppunit/TestLeaf.h b/3rdParty/CppUnit/src/include/cppunit/TestLeaf.h
new file mode 100644
index 0000000..c83b075
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/TestLeaf.h
@@ -0,0 +1,44 @@
+#ifndef CPPUNIT_TESTLEAF_H
+#define CPPUNIT_TESTLEAF_H
+
+#include <cppunit/Test.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+/*! \brief A single test object.
+ *
+ * Base class for single test case: a test that doesn't have any children.
+ *
+ */
+class CPPUNIT_API TestLeaf: public Test
+{
+public:
+  /*! Returns 1 as the default number of test cases invoked by run().
+   * 
+   * You may override this method when many test cases are invoked (RepeatedTest
+   * for example).
+   * 
+   * \return 1.
+   * \see Test::countTestCases().
+   */
+  int countTestCases() const;
+
+  /*! Returns the number of child of this test case: 0.
+   *
+   * You should never override this method: a TestLeaf as no children by definition.
+   *
+   * \return 0.
+   */
+  int getChildTestCount() const;
+
+  /*! Always throws std::out_of_range.
+   * \see Test::doGetChildTestAt().
+   */
+  Test *doGetChildTestAt( int index ) const;
+};
+
+CPPUNIT_NS_END
+
+#endif // CPPUNIT_TESTLEAF_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/TestListener.h b/3rdParty/CppUnit/src/include/cppunit/TestListener.h
new file mode 100644
index 0000000..330262d
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/TestListener.h
@@ -0,0 +1,148 @@
+#ifndef CPPUNIT_TESTLISTENER_H    // -*- C++ -*-
+#define CPPUNIT_TESTLISTENER_H
+
+#include <cppunit/Portability.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+class Exception;
+class Test;
+class TestFailure;
+class TestResult;
+
+
+/*! \brief Listener for test progress and result.
+ * \ingroup TrackingTestExecution
+ *
+ * Implementing the Observer pattern a TestListener may be registered
+ * to a TestResult to obtain information on the testing progress. Use
+ * specialized sub classes of TestListener for text output
+ * (TextTestProgressListener). Do not use the Listener for the test
+ * result output, use a subclass of Outputter instead.
+ *
+ * The test framework distinguishes between failures and errors.
+ * A failure is anticipated and checked for with assertions. Errors are
+ * unanticipated problems signified by exceptions that are not generated
+ * by the framework.
+ *
+ * Here is an example to track test time:
+ *
+ *
+ * \code
+ * #include <cppunit/TestListener.h>
+ * #include <cppunit/Test.h>
+ * #include <time.h>    // for clock()
+ *
+ * class TimingListener : public CppUnit::TestListener
+ * {
+ * public:
+ *   void startTest( CppUnit::Test *test )
+ *   {
+ *     _chronometer.start();
+ *   }
+ *  
+ *   void endTest( CppUnit::Test *test )
+ *   {
+ *     _chronometer.end();
+ *     addTest( test, _chronometer.elapsedTime() );
+ *   }
+ *
+ *   // ... (interface to add/read test timing result)
+ *
+ * private:
+ *   Clock _chronometer;
+ * };
+ * \endcode
+ *   
+ * And another example that track failure/success at test suite level and captures
+ * the TestPath of each suite:
+ * \code
+ * class SuiteTracker : public CppUnit::TestListener
+ * {
+ * public:
+ *   void startSuite( CppUnit::Test *suite )
+ *   {
+ *     m_currentPath.add( suite );
+ *   }
+ *   
+ *   void addFailure( const TestFailure &failure )
+ *   {
+ *     m_suiteFailure.top() = false;
+ *   }
+ * 
+ *   void endSuite( CppUnit::Test *suite )
+ *   {
+ *     m_suiteStatus.insert( std::make_pair( suite, m_suiteFailure.top() ) );
+ *     m_suitePaths.insert( std::make_pair( suite, m_currentPath ) );
+ *
+ *     m_currentPath.up();
+ *     m_suiteFailure.pop();
+ *   }
+ *
+ * private:
+ *   std::stack<bool> m_suiteFailure;
+ *   CppUnit::TestPath m_currentPath;
+ *   std::map<CppUnit::Test *, bool> m_suiteStatus;
+ *   std::map<CppUnit::Test *, CppUnit::TestPath> m_suitePaths;
+ * };
+ * \endcode
+ *
+ * \see TestResult
+ */
+class CPPUNIT_API TestListener
+{
+public:
+  virtual ~TestListener() {}
+  
+  /// Called when just before a TestCase is run.
+  virtual void startTest( Test * /*test*/ ) {}
+
+  /*! \brief Called when a failure occurs while running a test.
+   * \see TestFailure.
+   * \warning \a failure is a temporary object that is destroyed after the 
+   *          method call. Use TestFailure::clone() to create a duplicate.
+   */
+  virtual void addFailure( const TestFailure & /*failure*/ ) {}
+
+  /// Called just after a TestCase was run (even if a failure occured).
+  virtual void endTest( Test * /*test*/ ) {}
+
+  /*! \brief Called by a TestComposite just before running its child tests.
+   */
+  virtual void startSuite( Test * /*suite*/ ) {}
+
+  /*! \brief Called by a TestComposite after running its child tests.
+   */
+  virtual void endSuite( Test * /*suite*/ ) {}
+
+  /*! \brief Called by a TestRunner before running the test.
+   * 
+   * You can use this to do some global initialisation. A listener
+   * could also use to output a 'prolog' to the test run.
+   *
+   * \param test Test that is going to be run.
+   * \param eventManager Event manager used for the test run.
+   */
+  virtual void startTestRun( Test * /*test*/, 
+                             TestResult * /*eventManager*/ ) {}
+
+  /*! \brief Called by a TestRunner after running the test.
+   *
+   * TextTestProgressListener use this to emit a line break. You can also use this
+   * to do some global uninitialisation.
+   *
+   * \param test Test that was run.
+   * \param eventManager Event manager used for the test run.
+   */
+  virtual void endTestRun( Test * /*test*/, 
+                           TestResult * /*eventManager*/ ) {}
+};
+
+
+CPPUNIT_NS_END
+
+#endif // CPPUNIT_TESTLISTENER_H
+
+
diff --git a/3rdParty/CppUnit/src/include/cppunit/TestPath.h b/3rdParty/CppUnit/src/include/cppunit/TestPath.h
new file mode 100644
index 0000000..c3c851c
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/TestPath.h
@@ -0,0 +1,211 @@
+#ifndef CPPUNIT_TESTPATH_H
+#define CPPUNIT_TESTPATH_H
+
+#include <cppunit/Portability.h>
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( push )
+#pragma warning( disable: 4251 )  // X needs to have dll-interface to be used by clients of class Z
+#endif
+
+#include <cppunit/portability/CppUnitDeque.h>
+#include <string>
+
+CPPUNIT_NS_BEGIN
+
+
+class Test;
+
+#if CPPUNIT_NEED_DLL_DECL
+//  template class CPPUNIT_API std::deque<Test *>;
+#endif
+
+
+/*! \brief A List of Test representing a path to access a Test.
+ * \ingroup ExecutingTest
+ *
+ * The path can be converted to a string and resolved from a string with toString()
+ * and TestPath( Test *root, const std::string &pathAsString ).
+ *
+ * Pointed tests are not owned by the class.
+ *
+ * \see Test::resolvedTestPath()
+ */
+class CPPUNIT_API TestPath
+{
+public:
+  /*! \brief Constructs an invalid path.
+   * 
+   * The path is invalid until a test is added with add().
+   */
+  TestPath();
+
+  /*! \brief Constructs a valid path.
+   *
+   * \param root Test to add.
+   */
+  TestPath( Test *root );
+
+  /*! \brief Constructs a path using a slice of another path.
+   * \param otherPath Path the test are copied from.
+   * \param indexFirst Zero based index of the first test to copy. Adjusted to be in valid
+   *                   range. \a count is adjusted with \a indexFirst.
+   * \param count Number of tests to copy. If < 0 then all test starting from index
+   *              \a indexFirst are copied.
+   */
+  TestPath( const TestPath &otherPath, 
+            int indexFirst, 
+            int count = -1 );
+
+  /*! \brief Resolves a path from a string returned by toString().
+   *
+   * If \a pathAsString is an absolute path (begins with '/'), then the first test name
+   * of the path must be the name of \a searchRoot. Otherwise, \a pathAsString is a 
+   * relative path, and the first test found using Test::findTest() matching the first
+   * test name is used as root. An empty string resolve to a path containing 
+   * \a searchRoot.
+   *
+   * The resolved path is always valid.
+   *
+   * \param searchRoot Test used to resolve the path.
+   * \param pathAsString String that contains the path as a string created by toString().
+   * \exception std::invalid_argument if one of the test names can not be resolved.
+   * \see toString().
+   */
+  TestPath( Test *searchRoot, 
+            const std::string &pathAsString );
+
+  /*! \brief Copy constructor.
+   * \param other Object to copy.
+   */
+  TestPath( const TestPath &other );
+
+  virtual ~TestPath();
+
+  /*! \brief Tests if the path contains at least one test.
+   * \return \c true if the path contains at least one test, otherwise returns \c false.
+   */
+  virtual bool isValid() const;
+
+  /*! \brief Adds a test to the path.
+   * \param test Pointer on the test to add. Must not be \c NULL.
+   */
+  virtual void add( Test *test );
+
+  /*! \brief Adds all the tests of the specified path.
+   * \param path Path that contains the test to add.
+   */
+  virtual void add( const TestPath &path );
+
+  /*! \brief Inserts a test at the specified index.
+   * \param test Pointer on the test to insert. Must not be \c NULL.
+   * \param index Zero based index indicating where the test is inserted.
+   * \exception std::out_of_range is \a index < 0 or \a index > getTestCount().
+   */
+  virtual void insert( Test *test, int index );
+
+  /*! \brief Inserts all the tests at the specified path at a given index.
+   * \param path Path that contains the test to insert.
+   * \param index Zero based index indicating where the tests are inserted.
+   * \exception std::out_of_range is \a index < 0 or \a index > getTestCount(), and
+   *            \a path is valid.
+   */
+  virtual void insert( const TestPath &path, int index );
+
+  /*! \brief Removes all the test from the path.
+   *
+   * The path becomes invalid after this call.
+   */
+  virtual void removeTests();
+
+  /*! \brief Removes the test at the specified index of the path.
+   * \param index Zero based index of the test to remove.
+   * \exception std::out_of_range is \a index < 0 or \a index >= getTestCount().
+   */
+  virtual void removeTest( int index );
+
+  /*! \brief Removes the last test.
+   * \exception std::out_of_range is the path is invalid.
+   * \see isValid().
+   */
+  virtual void up();
+
+  /*! \brief Returns the number of tests in the path.
+   * \return Number of tests in the path.
+   */
+  virtual int getTestCount() const;
+
+  /*! \brief Returns the test of the specified index.
+   * \param index Zero based index of the test to return.
+   * \return Pointer on the test at index \a index. Never \c NULL.
+   * \exception std::out_of_range is \a index < 0 or \a index >= getTestCount().
+   */
+  virtual Test *getTestAt( int index ) const;
+
+  /*! \brief Get the last test of the path.
+   * \return Pointer on the last test (test at the bottom of the hierarchy). Never \c NULL.
+   * \exception std::out_of_range if the path is not valid ( isValid() returns \c false ).
+   */
+  virtual Test *getChildTest() const;
+
+  /*! \brief Returns the path as a string.
+   *
+   * For example, if a path is composed of three tests named "All Tests", "Math" and
+   * "Math::testAdd", toString() will return:
+   *
+   * "All Tests/Math/Math::testAdd".
+   * 
+   * \return A string composed of the test names separated with a '/'. It is a relative
+   *         path.
+   */
+  virtual std::string toString() const;
+
+  /*! \brief Assignment operator.
+   * \param other Object to copy.
+   * \return This object.
+   */
+  TestPath &operator =( const TestPath &other );
+
+protected:
+  /*! \brief Checks that the specified test index is within valid range.
+   * \param index Zero based index to check.
+   * \exception std::out_of_range is \a index < 0 or \a index >= getTestCount().
+   */
+  void checkIndexValid( int index ) const;
+
+  /// A list of test names.
+  typedef CppUnitDeque<std::string> PathTestNames;
+
+  /*! \brief Splits a path string into its test name components.
+   * \param pathAsString Path string created with toString().
+   * \param testNames Test name components are added to that container.
+   * \return \c true if the path is relative (does not begin with '/'), \c false
+   *         if it is absolute (begin with '/').
+   */
+  bool splitPathString( const std::string &pathAsString,
+                        PathTestNames &testNames );
+
+  /*! \brief Finds the actual root of a path string and get the path string name components.
+   * \param searchRoot Test used as root if the path string is absolute, or to search
+   *                   the root test if the path string is relative.
+   * \param pathAsString Path string. May be absolute or relative.
+   * \param testNames Test name components are added to that container.
+   * \return Pointer on the resolved root test. Never \c NULL.
+   * \exception std::invalid_argument if either the root name can not be resolved or if
+   *            pathAsString contains no name components.
+   */
+  Test *findActualRoot( Test *searchRoot,
+                        const std::string &pathAsString,
+                        PathTestNames &testNames );
+
+protected:
+  typedef CppUnitDeque<Test *> Tests;
+  Tests m_tests;
+
+};
+
+
+CPPUNIT_NS_END
+
+#endif // CPPUNIT_TESTPATH_H
+
diff --git a/3rdParty/CppUnit/src/include/cppunit/TestResult.h b/3rdParty/CppUnit/src/include/cppunit/TestResult.h
new file mode 100644
index 0000000..e7e1050
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/TestResult.h
@@ -0,0 +1,156 @@
+#ifndef CPPUNIT_TESTRESULT_H
+#define CPPUNIT_TESTRESULT_H
+
+#include <cppunit/Portability.h>
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( push )
+#pragma warning( disable: 4251 )  // X needs to have dll-interface to be used by clients of class Z
+#endif
+
+#include <cppunit/SynchronizedObject.h>
+#include <cppunit/portability/CppUnitDeque.h>
+#include <string>
+
+CPPUNIT_NS_BEGIN
+
+
+class Exception;
+class Functor;
+class Protector;
+class ProtectorChain;
+class Test;
+class TestFailure;
+class TestListener;
+
+
+#if CPPUNIT_NEED_DLL_DECL
+//  template class CPPUNIT_API std::deque<TestListener *>;
+#endif
+
+/*! \brief Manages TestListener.
+ * \ingroup TrackingTestExecution
+ *
+ * A single instance of this class is used when running the test. It is usually
+ * created by the test runner (TestRunner).
+ *
+ * This class shouldn't have to be inherited from. Use a TestListener
+ * or one of its subclasses to be informed of the ongoing tests.
+ * Use a Outputter to receive a test summary once it has finished
+ *
+ * TestResult supplies a template method 'setSynchronizationObject()'
+ * so that subclasses can provide mutual exclusion in the face of multiple
+ * threads.  This can be useful when tests execute in one thread and
+ * they fill a subclass of TestResult which effects change in another 
+ * thread.  To have mutual exclusion, override setSynchronizationObject()
+ * and make sure that you create an instance of ExclusiveZone at the 
+ * beginning of each method.
+ *
+ * \see Test, TestListener, TestResultCollector, Outputter.
+ */
+class CPPUNIT_API TestResult : protected SynchronizedObject
+{
+public:
+  /// Construct a TestResult
+  TestResult( SynchronizationObject *syncObject = 0 );
+
+  /// Destroys a test result
+  virtual ~TestResult();
+
+  virtual void addListener( TestListener *listener );
+
+  virtual void removeListener( TestListener *listener );
+
+  /// Resets the stop flag.
+  virtual void reset();
+  
+  /// Stop testing
+  virtual void stop();
+
+  /// Returns whether testing should be stopped
+  virtual bool shouldStop() const;
+
+  /// Informs TestListener that a test will be started.
+  virtual void startTest( Test *test );
+
+  /*! \brief Adds an error to the list of errors. 
+   *  The passed in exception
+   *  caused the error
+   */
+  virtual void addError( Test *test, Exception *e );
+
+  /*! \brief Adds a failure to the list of failures. The passed in exception
+   * caused the failure.
+   */
+  virtual void addFailure( Test *test, Exception *e );
+
+  /// Informs TestListener that a test was completed.
+  virtual void endTest( Test *test );
+
+  /// Informs TestListener that a test suite will be started.
+  virtual void startSuite( Test *test );
+
+  /// Informs TestListener that a test suite was completed.
+  virtual void endSuite( Test *test );
+
+  /*! \brief Run the specified test.
+   * 
+   * Calls startTestRun(), test->run(this), and finally endTestRun().
+   */
+  virtual void runTest( Test *test );
+
+  /*! \brief Protects a call to the specified functor.
+   *
+   * See Protector to understand how protector works. A default protector is
+   * always present. It captures CppUnit::Exception, std::exception and
+   * any other exceptions, retrieving as much as possible information about
+   * the exception as possible.
+   *
+   * Additional Protector can be added to the chain to support other exception
+   * types using pushProtector() and popProtector().
+   *
+   * \param functor Functor to call (typically a call to setUp(), runTest() or
+   *                tearDown().
+   * \param test Test the functor is associated to (used for failure reporting).
+   * \param shortDescription Short description override for the failure message.
+   */
+  virtual bool protect( const Functor &functor,
+                        Test *test,
+                        const std::string &shortDescription = std::string("") );
+
+  /// Adds the specified protector to the protector chain.
+  virtual void pushProtector( Protector *protector );
+
+  /// Removes the last protector from the protector chain.
+  virtual void popProtector();
+
+protected:
+  /*! \brief Called to add a failure to the list of failures.
+   */
+  void addFailure( const TestFailure &failure );
+
+  virtual void startTestRun( Test *test );
+  virtual void endTestRun( Test *test );
+  
+protected:
+  typedef CppUnitDeque<TestListener *> TestListeners;
+  TestListeners m_listeners;
+  ProtectorChain *m_protectorChain;
+  bool m_stop;
+
+private: 
+  TestResult( const TestResult &other );
+  TestResult &operator =( const TestResult &other );
+};
+
+
+CPPUNIT_NS_END
+
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( pop )
+#endif
+
+#endif // CPPUNIT_TESTRESULT_H
+
+
diff --git a/3rdParty/CppUnit/src/include/cppunit/TestResultCollector.h b/3rdParty/CppUnit/src/include/cppunit/TestResultCollector.h
new file mode 100644
index 0000000..01b0a54
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/TestResultCollector.h
@@ -0,0 +1,87 @@
+#ifndef CPPUNIT_TESTRESULTCOLLECTOR_H
+#define CPPUNIT_TESTRESULTCOLLECTOR_H
+
+#include <cppunit/Portability.h>
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( push )
+#pragma warning( disable: 4251 4660 )  // X needs to have dll-interface to be used by clients of class Z
+#endif
+
+#include <cppunit/TestSuccessListener.h>
+#include <cppunit/portability/CppUnitDeque.h>
+
+
+CPPUNIT_NS_BEGIN
+
+#if CPPUNIT_NEED_DLL_DECL
+//  template class CPPUNIT_API std::deque<TestFailure *>;
+//  template class CPPUNIT_API std::deque<Test *>;
+#endif
+
+
+/*! \brief Collects test result.
+ * \ingroup WritingTestResult
+ * \ingroup BrowsingCollectedTestResult
+ * 
+ * A TestResultCollector is a TestListener which collects the results of executing 
+ * a test case. It is an instance of the Collecting Parameter pattern.
+ *
+ * The test framework distinguishes between failures and errors.
+ * A failure is anticipated and checked for with assertions. Errors are
+ * unanticipated problems signified by exceptions that are not generated
+ * by the framework.
+ * \see TestListener, TestFailure.
+ */
+class CPPUNIT_API TestResultCollector : public TestSuccessListener
+{
+public:
+  typedef CppUnitDeque<TestFailure *> TestFailures;
+  typedef CppUnitDeque<Test *> Tests;
+
+
+  /*! Constructs a TestResultCollector object.
+   */
+  TestResultCollector( SynchronizationObject *syncObject = 0 );
+
+  /// Destructor.
+  virtual ~TestResultCollector();
+
+  void startTest( Test *test );
+  void addFailure( const TestFailure &failure );
+
+  virtual void reset();
+
+  virtual int runTests() const;
+  virtual int testErrors() const;
+  virtual int testFailures() const;
+  virtual int testFailuresTotal() const;
+
+  virtual const TestFailures& failures() const;
+  virtual const Tests &tests() const;
+
+protected:
+  void freeFailures();
+
+  Tests m_tests;
+  TestFailures m_failures;
+  int m_testErrors;
+
+private:
+  /// Prevents the use of the copy constructor.
+  TestResultCollector( const TestResultCollector &copy );
+
+  /// Prevents the use of the copy operator.
+  void operator =( const TestResultCollector &copy );
+};
+
+
+
+CPPUNIT_NS_END
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( pop )
+#endif
+
+
+#endif  // CPPUNIT_TESTRESULTCOLLECTOR_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/TestRunner.h b/3rdParty/CppUnit/src/include/cppunit/TestRunner.h
new file mode 100644
index 0000000..930370a
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/TestRunner.h
@@ -0,0 +1,135 @@
+#ifndef CPPUNIT_TESTRUNNER_H
+#define CPPUNIT_TESTRUNNER_H
+
+#include <cppunit/TestSuite.h>
+#include <string>
+
+CPPUNIT_NS_BEGIN
+
+
+class Test;
+class TestResult;
+
+
+/*! \brief Generic test runner.
+ * \ingroup ExecutingTest
+ *
+ * The TestRunner assumes ownership of all added tests: you can not add test
+ * or suite that are local variable since they can't be deleted.
+ *
+ * Example of usage:
+ * \code
+ * #include <cppunit/extensions/TestFactoryRegistry.h>
+ * #include <cppunit/CompilerOutputter.h>
+ * #include <cppunit/TestResult.h>
+ * #include <cppunit/TestResultCollector.h>
+ * #include <cppunit/TestRunner.h>
+ * #include <cppunit/TextTestProgressListener.h>
+ * 
+ * 
+ * int 
+ * main( int argc, char* argv[] )
+ * {
+ *   std::string testPath = (argc > 1) ? std::string(argv[1]) : "";
+ * 
+ *   // Create the event manager and test controller
+ *   CppUnit::TestResult controller;
+ * 
+ *   // Add a listener that colllects test result
+ *   CppUnit::TestResultCollector result;
+ *   controller.addListener( &result );        
+ * 
+ *   // Add a listener that print dots as test run.
+ *   CppUnit::TextTestProgressListener progress;
+ *   controller.addListener( &progress );      
+ * 
+ *   // Add the top suite to the test runner
+ *   CppUnit::TestRunner runner;
+ *   runner.addTest( CppUnit::TestFactoryRegistry::getRegistry().makeTest() );   
+ *   try
+ *   {
+ *     std::cout << "Running "  <<  testPath;
+ *     runner.run( controller, testPath );
+ * 
+ *     std::cerr << std::endl;
+ * 
+ *     // Print test in a compiler compatible format.
+ *     CppUnit::CompilerOutputter outputter( &result, std::cerr );
+ *     outputter.write();                      
+ *   }
+ *   catch ( std::invalid_argument &e )  // Test path not resolved
+ *   {
+ *     std::cerr  <<  std::endl  
+ *                <<  "ERROR: "  <<  e.what()
+ *                << std::endl;
+ *     return 0;
+ *   }
+ * 
+ *   return result.wasSuccessful() ? 0 : 1;
+ * }
+ * \endcode
+ */
+class CPPUNIT_API TestRunner
+{
+public:
+  /*! \brief Constructs a TestRunner object.
+   */
+  TestRunner(  );
+
+  /// Destructor.
+  virtual ~TestRunner();
+
+  /*! \brief Adds the specified test.
+   * \param test Test to add. The TestRunner takes ownership of the test.
+   */
+  virtual void addTest( Test *test );
+
+  /*! \brief Runs a test using the specified controller.
+   * \param controller Event manager and controller used for testing
+   * \param testPath Test path string. See Test::resolveTestPath() for detail.
+   * \exception std::invalid_argument if no test matching \a testPath is found.
+   *                                  see TestPath::TestPath( Test*, const std::string &)
+   *                                  for detail.
+   */
+  virtual void run( TestResult &controller,
+                    const std::string &testPath = "" );
+
+protected:
+  /*! \brief (INTERNAL) Mutating test suite.
+   */
+  class CPPUNIT_API WrappingSuite : public TestSuite
+  {
+  public:
+    WrappingSuite( const std::string &name = "All Tests" );
+
+    int getChildTestCount() const;
+
+    std::string getName() const;
+
+    void run( TestResult *result );
+
+  protected:
+    Test *doGetChildTestAt( int index ) const;
+
+    bool hasOnlyOneTest() const;
+
+    Test *getUniqueChildTest() const;
+  };
+
+protected:
+  WrappingSuite *m_suite;
+
+private:
+  /// Prevents the use of the copy constructor.
+  TestRunner( const TestRunner &copy );
+
+  /// Prevents the use of the copy operator.
+  void operator =( const TestRunner &copy );
+
+private:
+};
+
+
+CPPUNIT_NS_END
+
+#endif  // CPPUNIT_TESTRUNNER_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/TestSuccessListener.h b/3rdParty/CppUnit/src/include/cppunit/TestSuccessListener.h
new file mode 100644
index 0000000..60c5ff5
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/TestSuccessListener.h
@@ -0,0 +1,39 @@
+#ifndef CPPUNIT_TESTSUCCESSLISTENER_H
+#define CPPUNIT_TESTSUCCESSLISTENER_H
+
+#include <cppunit/SynchronizedObject.h>
+#include <cppunit/TestListener.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+/*! \brief TestListener that checks if any test case failed.
+ * \ingroup TrackingTestExecution
+ */
+class CPPUNIT_API TestSuccessListener : public TestListener,
+                                        public SynchronizedObject
+{
+public:
+  /*! Constructs a TestSuccessListener object.
+   */
+  TestSuccessListener( SynchronizationObject *syncObject = 0 );
+
+  /// Destructor.
+  virtual ~TestSuccessListener();
+
+  virtual void reset();
+
+  void addFailure( const TestFailure &failure );
+
+  /// Returns whether the entire test was successful or not.
+  virtual bool wasSuccessful() const;
+
+private:
+  bool m_success;
+};
+
+
+CPPUNIT_NS_END
+
+#endif  // CPPUNIT_TESTSUCCESSLISTENER_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/TestSuite.h b/3rdParty/CppUnit/src/include/cppunit/TestSuite.h
new file mode 100644
index 0000000..2b9cd8d
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/TestSuite.h
@@ -0,0 +1,80 @@
+#ifndef CPPUNIT_TESTSUITE_H    // -*- C++ -*-
+#define CPPUNIT_TESTSUITE_H
+
+#include <cppunit/Portability.h>
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( push )
+#pragma warning( disable: 4251 )  // X needs to have dll-interface to be used by clients of class Z
+#endif
+
+#include <cppunit/TestComposite.h>
+#include <cppunit/portability/CppUnitVector.h>
+
+CPPUNIT_NS_BEGIN
+
+
+#if CPPUNIT_NEED_DLL_DECL
+//  template class CPPUNIT_API std::vector<Test *>;
+#endif
+
+
+/*! \brief A Composite of Tests.
+ * \ingroup CreatingTestSuite
+ *
+ * It runs a collection of test cases. Here is an example.
+ * \code
+ * CppUnit::TestSuite *suite= new CppUnit::TestSuite();
+ * suite->addTest(new CppUnit::TestCaller<MathTest> (
+ *                  "testAdd", testAdd));
+ * suite->addTest(new CppUnit::TestCaller<MathTest> (
+ *                  "testDivideByZero", testDivideByZero));
+ * \endcode
+ * Note that \link TestSuite TestSuites \endlink assume lifetime
+ * control for any tests added to them.
+ *
+ * TestSuites do not register themselves in the TestRegistry.
+ * \see Test 
+ * \see TestCaller
+ */
+class CPPUNIT_API TestSuite : public TestComposite
+{
+public:
+  /*! Constructs a test suite with the specified name.
+   */
+  TestSuite( std::string name = "" );
+
+  ~TestSuite();
+
+  /*! Adds the specified test to the suite.
+   * \param test Test to add. Must not be \c NULL.
+    */
+  void addTest( Test *test );
+
+  /*! Returns the list of the tests (DEPRECATED).
+   * \deprecated Use getChildTestCount() & getChildTestAt() of the 
+   *             TestComposite interface instead.
+   * \return Reference on a vector that contains the tests of the suite.
+   */
+  const CppUnitVector<Test *> &getTests() const;
+
+  /*! Destroys all the tests of the suite.
+   */
+  virtual void deleteContents();
+
+  int getChildTestCount() const;
+
+  Test *doGetChildTestAt( int index ) const;
+
+private:
+  CppUnitVector<Test *> m_tests;
+};
+
+
+CPPUNIT_NS_END
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( pop )
+#endif
+
+#endif // CPPUNIT_TESTSUITE_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/TextOutputter.h b/3rdParty/CppUnit/src/include/cppunit/TextOutputter.h
new file mode 100644
index 0000000..6bd9cea
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/TextOutputter.h
@@ -0,0 +1,59 @@
+#ifndef CPPUNIT_TEXTOUTPUTTER_H
+#define CPPUNIT_TEXTOUTPUTTER_H
+
+#include <cppunit/Portability.h>
+#include <cppunit/Outputter.h>
+#include <cppunit/portability/Stream.h>
+
+CPPUNIT_NS_BEGIN
+
+
+class Exception;
+class SourceLine;
+class TestResultCollector;
+class TestFailure;
+
+
+/*! \brief Prints a TestResultCollector to a text stream.
+ * \ingroup WritingTestResult
+ */
+class CPPUNIT_API TextOutputter : public Outputter
+{
+public:
+  TextOutputter( TestResultCollector *result,
+                 OStream &stream );
+
+  /// Destructor.
+  virtual ~TextOutputter();
+
+  void write();
+  virtual void printFailures();
+  virtual void printHeader();
+
+  virtual void printFailure( TestFailure *failure,
+                             int failureNumber );
+  virtual void printFailureListMark( int failureNumber );
+  virtual void printFailureTestName( TestFailure *failure );
+  virtual void printFailureType( TestFailure *failure );
+  virtual void printFailureLocation( SourceLine sourceLine );
+  virtual void printFailureDetail( Exception *thrownException );
+  virtual void printFailureWarning();
+  virtual void printStatistics();
+
+protected:
+  TestResultCollector *m_result;
+  OStream &m_stream;
+
+private:
+  /// Prevents the use of the copy constructor.
+  TextOutputter( const TextOutputter &copy );
+
+  /// Prevents the use of the copy operator.
+  void operator =( const TextOutputter &copy );
+};
+
+
+
+CPPUNIT_NS_END
+
+#endif  // CPPUNIT_TEXTOUTPUTTER_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/TextTestProgressListener.h b/3rdParty/CppUnit/src/include/cppunit/TextTestProgressListener.h
new file mode 100644
index 0000000..7521c40
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/TextTestProgressListener.h
@@ -0,0 +1,44 @@
+#ifndef CPPUNIT_TEXTTESTPROGRESSLISTENER_H
+#define CPPUNIT_TEXTTESTPROGRESSLISTENER_H
+
+#include <cppunit/TestListener.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+/*! 
+ * \brief TestListener that show the status of each TestCase test result.
+ * \ingroup TrackingTestExecution
+ */
+class CPPUNIT_API TextTestProgressListener : public TestListener
+{
+public:
+  /*! Constructs a TextTestProgressListener object.
+   */
+  TextTestProgressListener();
+
+  /// Destructor.
+  virtual ~TextTestProgressListener();
+
+  void startTest( Test *test );
+
+  void addFailure( const TestFailure &failure );
+
+  void endTestRun( Test *test, 
+                   TestResult *eventManager );
+
+private:
+  /// Prevents the use of the copy constructor.
+  TextTestProgressListener( const TextTestProgressListener &copy );
+
+  /// Prevents the use of the copy operator.
+  void operator =( const TextTestProgressListener &copy );
+
+private:
+};
+
+
+CPPUNIT_NS_END
+
+#endif  // CPPUNIT_TEXTTESTPROGRESSLISTENER_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/TextTestResult.h b/3rdParty/CppUnit/src/include/cppunit/TextTestResult.h
new file mode 100644
index 0000000..e7b1fa3
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/TextTestResult.h
@@ -0,0 +1,39 @@
+#ifndef CPPUNIT_TEXTTESTRESULT_H
+#define CPPUNIT_TEXTTESTRESULT_H
+
+#include <cppunit/TestResult.h>
+#include <cppunit/TestResultCollector.h>
+#include <cppunit/portability/Stream.h>
+
+CPPUNIT_NS_BEGIN
+
+
+class SourceLine;
+class Exception;
+class Test;
+
+/*! \brief Holds printable test result (DEPRECATED).
+ * \ingroup TrackingTestExecution
+ * 
+ * deprecated Use class TextTestProgressListener and TextOutputter instead.
+ */
+class CPPUNIT_API TextTestResult : public TestResult,
+                                   public TestResultCollector
+{
+public:
+  TextTestResult();
+
+  virtual void addFailure( const TestFailure &failure );
+  virtual void startTest( Test *test );
+  virtual void print( OStream &stream );
+};
+
+/** insertion operator for easy output */
+CPPUNIT_API OStream &operator <<( OStream &stream, 
+                                  TextTestResult &result );
+
+CPPUNIT_NS_END
+
+#endif // CPPUNIT_TEXTTESTRESULT_H
+
+
diff --git a/3rdParty/CppUnit/src/include/cppunit/XmlOutputter.h b/3rdParty/CppUnit/src/include/cppunit/XmlOutputter.h
new file mode 100644
index 0000000..0de9676
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/XmlOutputter.h
@@ -0,0 +1,167 @@
+#ifndef CPPUNIT_XMLTESTRESULTOUTPUTTER_H
+#define CPPUNIT_XMLTESTRESULTOUTPUTTER_H
+
+#include <cppunit/Portability.h>
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( push )
+#pragma warning( disable: 4251 )  // X needs to have dll-interface to be used by clients of class Z
+#endif
+
+#include <cppunit/Outputter.h>
+#include <cppunit/portability/CppUnitDeque.h>
+#include <cppunit/portability/CppUnitMap.h>
+#include <cppunit/portability/Stream.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+class Test;
+class TestFailure;
+class TestResultCollector;
+class XmlDocument;
+class XmlElement;
+class XmlOutputterHook;
+
+
+/*! \brief Outputs a TestResultCollector in XML format.
+ * \ingroup WritingTestResult
+ *
+ * Save the test result as a XML stream. 
+ *
+ * Additional datas can be added to the XML document using XmlOutputterHook. 
+ * Hook are not owned by the XmlOutputter. They should be valid until 
+ * destruction of the XmlOutputter. They can be removed with removeHook().
+ *
+ * \see XmlDocument, XmlElement, XmlOutputterHook.
+ */
+class CPPUNIT_API XmlOutputter : public Outputter
+{
+public:
+  /*! \brief Constructs a XmlOutputter object.
+   * \param result Result of the test run.
+   * \param stream Stream used to output the XML output.
+   * \param encoding Encoding used in the XML file (default is Latin-1). 
+   */
+  XmlOutputter( TestResultCollector *result,
+                OStream &stream,
+                std::string encoding = std::string("ISO-8859-1") );
+
+  /// Destructor.
+  virtual ~XmlOutputter();
+
+  /*! \brief Adds the specified hook to the outputter.
+   * \param hook Hook to add. Must not be \c NULL.
+   */
+  virtual void addHook( XmlOutputterHook *hook );
+
+  /*! \brief Removes the specified hook from the outputter.
+   * \param hook Hook to remove.
+   */
+  virtual void removeHook( XmlOutputterHook *hook );
+
+  /*! \brief Writes the specified result as an XML document to the stream.
+   *
+   * Refer to examples/cppunittest/XmlOutputterTest.cpp for example
+   * of use and XML document structure.
+   */
+  virtual void write();
+
+  /*! \brief Sets the XSL style sheet used.
+   *
+   * \param styleSheet Name of the style sheet used. If empty, then no style sheet
+   *                   is used (default).
+   */
+  virtual void setStyleSheet( const std::string &styleSheet );
+
+  /*! \brief set the output document as standalone or not.
+   *
+   *  For the output document, specify wether it's a standalone XML
+   *  document, or not.
+   *
+   *  \param standalone if true, the output will be specified as standalone.
+   *         if false, it will be not.
+   */
+  virtual void setStandalone( bool standalone );
+
+  typedef CppUnitMap<Test *,TestFailure*, std::less<Test*> > FailedTests;
+
+  /*! \brief Sets the root element and adds its children.
+   *
+   * Set the root element of the XML Document and add its child elements.
+   *
+   * For all hooks, call beginDocument() just after creating the root element (it
+   * is empty at this time), and endDocument() once all the datas have been added
+   * to the root element.
+   */
+  virtual void setRootNode();
+
+  virtual void addFailedTests( FailedTests &failedTests,
+                               XmlElement *rootNode );
+
+  virtual void addSuccessfulTests( FailedTests &failedTests,
+                                   XmlElement *rootNode );
+
+  /*! \brief Adds the statics element to the root node.
+   * 
+   * Creates a new element containing statistics data and adds it to the root element.
+   * Then, for all hooks, call statisticsAdded().
+   * \param rootNode Root element.
+   */
+  virtual void addStatistics( XmlElement *rootNode );
+
+  /*! \brief Adds a failed test to the failed tests node.
+   * Creates a new element containing datas about the failed test, and adds it to 
+   * the failed tests element.
+   * Then, for all hooks, call failTestAdded().
+   */
+  virtual void addFailedTest( Test *test,
+                              TestFailure *failure,
+                              int testNumber,
+                              XmlElement *testsNode );
+
+  virtual void addFailureLocation( TestFailure *failure,
+                                   XmlElement *testElement );
+
+
+  /*! \brief Adds a successful test to the successful tests node.
+   * Creates a new element containing datas about the successful test, and adds it to 
+   * the successful tests element.
+   * Then, for all hooks, call successfulTestAdded().
+   */
+  virtual void addSuccessfulTest( Test *test, 
+                                  int testNumber,
+                                  XmlElement *testsNode );
+protected:
+  virtual void fillFailedTestsMap( FailedTests &failedTests );
+
+protected:
+  typedef CppUnitDeque<XmlOutputterHook *> Hooks;
+
+  TestResultCollector *m_result;
+  OStream &m_stream;
+  std::string m_encoding;
+  std::string m_styleSheet;
+  XmlDocument *m_xml;
+  Hooks m_hooks;
+
+private:
+  /// Prevents the use of the copy constructor.
+  XmlOutputter( const XmlOutputter &copy );
+
+  /// Prevents the use of the copy operator.
+  void operator =( const XmlOutputter &copy );
+
+private:
+};
+
+
+CPPUNIT_NS_END
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( pop )
+#endif
+
+
+#endif  // CPPUNIT_XMLTESTRESULTOUTPUTTER_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/XmlOutputterHook.h b/3rdParty/CppUnit/src/include/cppunit/XmlOutputterHook.h
new file mode 100644
index 0000000..5ded3b1
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/XmlOutputterHook.h
@@ -0,0 +1,163 @@
+#ifndef CPPUNIT_XMLOUTPUTTERHOOK_H
+#define CPPUNIT_XMLOUTPUTTERHOOK_H
+
+#include <cppunit/Portability.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+class Test;
+class TestFailure;
+class XmlDocument;
+class XmlElement;
+
+
+
+/*! \brief Hook to customize Xml output.
+ *
+ * XmlOutputterHook can be passed to XmlOutputter to customize the XmlDocument.
+ *
+ * Common customizations are:
+ * - adding some datas to successfull or failed test with
+ *   failTestAdded() and successfulTestAdded(),
+ * - adding some statistics with statisticsAdded(),
+ * - adding other datas with beginDocument() or endDocument().
+ *
+ * See examples/ClockerPlugIn which makes use of most the hook.
+ *
+ * Another simple example of an outputter hook is shown below. It may be  
+ * used to add some meta information to your result files. In the example,
+ * the author name as well as the project name and test creation date is
+ * added to the head of the xml file.
+ *
+ * In order to make this information stored within the xml file, the virtual 
+ * member function beginDocument() is overriden where a new 
+ * XmlElement object is created.
+ *
+ * This element is simply added to the root node of the document which
+ * makes the information automatically being stored when the xml file
+ * is written.
+ *
+ * \code
+ * #include <cppunit/XmlOutputterHook.h>
+ * #include <cppunit/XmlElement.h>
+ * #include <cppunit/tools/StringTools.h>
+ * 
+ * ...
+ * 
+ * class MyXmlOutputterHook : public CppUnit::XmlOutputterHook
+ * {
+ * public:
+ *   MyXmlOutputterHook(const std::string projectName,
+ *                      const std::string author)
+ *   {
+ *      m_projectName = projectName;
+ *      m_author      = author;
+ *   };
+ * 
+ *   virtual ~MyXmlOutputterHook()
+ *   {
+ *   };
+ * 
+ *   void beginDocument(CppUnit::XmlDocument* document)
+ *   {
+ *     if (!document)
+ *       return;
+ *
+ *     // dump current time
+ *     std::string szDate          = CppUnit::StringTools::toString( (int)time(0) );
+ *     CppUnit::XmlElement* metaEl = new CppUnit::XmlElement("SuiteInfo", 
+ *                                                           "");
+ *
+ *     metaEl->addElement( new CppUnit::XmlElement("Author", m_author) );
+ *     metaEl->addElement( new CppUnit::XmlElement("Project", m_projectName) );
+ *     metaEl->addElement( new CppUnit::XmlElement("Date", szDate ) );
+ *    
+ *     document->rootElement().addElement(metaEl);
+ *   };
+ * private:
+ *   std::string m_projectName;
+ *   std::string m_author;
+ * }; 
+ * \endcode
+ *
+ * Within your application's main code, you need to snap the hook 
+ * object into your xml outputter object like shown below:
+ *
+ * \code
+ * CppUnit::TextUi::TestRunner runner;
+ * std::ofstream outputFile("testResults.xml");
+ * 
+ * CppUnit::XmlOutputter* outputter = new CppUnit::XmlOutputter( &runner.result(),
+ *                                                               outputFile );    
+ * MyXmlOutputterHook hook("myProject", "meAuthor");
+ * outputter->addHook(&hook);
+ * runner.setOutputter(outputter);    
+ * runner.addTest( VectorFixture::suite() );   
+ * runner.run();
+ * outputFile.close();
+ * \endcode
+ *
+ * This results into the following output:
+ *
+ * \code
+ * <TestRun>
+ *   <suiteInfo>
+ *     <author>meAuthor</author>
+ *     <project>myProject</project>
+ *     <date>1028143912</date>
+ *   </suiteInfo>
+ *   <FailedTests>
+ *    ...
+ * \endcode
+ *
+ * \see XmlOutputter, CppUnitTestPlugIn.
+ */
+class CPPUNIT_API XmlOutputterHook
+{
+public:
+  /*! Called before any elements is added to the root element.
+   * \param document XML Document being created.
+   */
+  virtual void beginDocument( XmlDocument *document );
+
+  /*! Called after adding all elements to the root element.
+   * \param document XML Document being created.
+   */
+  virtual void endDocument( XmlDocument *document );
+
+  /*! Called after adding a fail test element.
+   * \param document XML Document being created.
+   * \param testElement \<FailedTest\> element.
+   * \param test Test that failed.
+   * \param failure Test failure data.
+   */
+  virtual void failTestAdded( XmlDocument *document,
+                              XmlElement *testElement,
+                              Test *test,
+                              TestFailure *failure );
+
+  /*! Called after adding a successful test element.
+   * \param document XML Document being created.
+   * \param testElement \<Test\> element.
+   * \param test Test that was successful.
+   */
+  virtual void successfulTestAdded( XmlDocument *document,
+                                    XmlElement *testElement,
+                                    Test *test );
+
+  /*! Called after adding the statistic element.
+   * \param document XML Document being created.
+   * \param statisticsElement \<Statistics\> element.
+   */
+  virtual void statisticsAdded( XmlDocument *document,
+                                XmlElement *statisticsElement );
+
+  virtual ~XmlOutputterHook() {}
+};
+
+
+CPPUNIT_NS_END
+
+#endif  // CPPUNIT_XMLOUTPUTTERHOOK_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/config-auto.h b/3rdParty/CppUnit/src/include/cppunit/config-auto.h
new file mode 100644
index 0000000..58b3d6e
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/config-auto.h
@@ -0,0 +1,161 @@
+#ifndef _INCLUDE_CPPUNIT_CONFIG_AUTO_H
+#define _INCLUDE_CPPUNIT_CONFIG_AUTO_H 1
+ 
+/* include/cppunit/config-auto.h. Generated automatically at end of configure. */
+/* config/config.h.  Generated by configure.  */
+/* config/config.h.in.  Generated from configure.in by autoheader.  */
+
+/* define if library uses std::string::compare(string,pos,n) */
+/* #undef CPPUNIT_FUNC_STRING_COMPARE_STRING_FIRST */
+
+
+#define CPPUNIT_HAVE_CPP_CAST
+
+/* define if the library defines strstream */
+#ifndef CPPUNIT_HAVE_CLASS_STRSTREAM 
+#define CPPUNIT_HAVE_CLASS_STRSTREAM  1 
+#endif
+
+/* Define to 1 if you have the <cmath> header file. */
+#ifndef CPPUNIT_HAVE_CMATH 
+#define CPPUNIT_HAVE_CMATH  1 
+#endif
+
+/* Define if you have the GNU dld library. */
+/* #undef CPPUNIT_HAVE_DLD */
+
+/* Define to 1 if you have the `dlerror' function. */
+#ifndef CPPUNIT_HAVE_DLERROR 
+#define CPPUNIT_HAVE_DLERROR  1 
+#endif
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#ifndef CPPUNIT_HAVE_DLFCN_H 
+#define CPPUNIT_HAVE_DLFCN_H  1 
+#endif
+
+/* define if the compiler supports GCC C++ ABI name demangling */
+#ifndef CPPUNIT_HAVE_GCC_ABI_DEMANGLE 
+#define CPPUNIT_HAVE_GCC_ABI_DEMANGLE  1 
+#endif
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#ifndef CPPUNIT_HAVE_INTTYPES_H 
+#define CPPUNIT_HAVE_INTTYPES_H  1 
+#endif
+
+/* Define if you have the libdl library or equivalent. */
+#ifndef CPPUNIT_HAVE_LIBDL 
+#define CPPUNIT_HAVE_LIBDL  1 
+#endif
+
+/* Define to 1 if you have the <memory.h> header file. */
+#ifndef CPPUNIT_HAVE_MEMORY_H 
+#define CPPUNIT_HAVE_MEMORY_H  1 
+#endif
+
+/* define to 1 if the compiler implements namespaces */
+#ifndef CPPUNIT_HAVE_NAMESPACES 
+#define CPPUNIT_HAVE_NAMESPACES  1 
+#endif
+
+/* define if the compiler supports Run-Time Type Identification */
+#ifndef CPPUNIT_HAVE_RTTI 
+#define CPPUNIT_HAVE_RTTI  1 
+#endif
+
+/* Define if you have the shl_load function. */
+/* #undef CPPUNIT_HAVE_SHL_LOAD */
+
+/* define if the compiler has stringstream */
+#ifndef CPPUNIT_HAVE_SSTREAM 
+#define CPPUNIT_HAVE_SSTREAM  1 
+#endif
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#ifndef CPPUNIT_HAVE_STDINT_H 
+#define CPPUNIT_HAVE_STDINT_H  1 
+#endif
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#ifndef CPPUNIT_HAVE_STDLIB_H 
+#define CPPUNIT_HAVE_STDLIB_H  1 
+#endif
+
+/* Define to 1 if you have the <strings.h> header file. */
+#ifndef CPPUNIT_HAVE_STRINGS_H 
+#define CPPUNIT_HAVE_STRINGS_H  1 
+#endif
+
+/* Define to 1 if you have the <string.h> header file. */
+#ifndef CPPUNIT_HAVE_STRING_H 
+#define CPPUNIT_HAVE_STRING_H  1 
+#endif
+
+/* Define to 1 if you have the <strstream> header file. */
+#ifndef CPPUNIT_HAVE_STRSTREAM 
+#define CPPUNIT_HAVE_STRSTREAM  1 
+#endif
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#ifndef CPPUNIT_HAVE_SYS_STAT_H 
+#define CPPUNIT_HAVE_SYS_STAT_H  1 
+#endif
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#ifndef CPPUNIT_HAVE_SYS_TYPES_H 
+#define CPPUNIT_HAVE_SYS_TYPES_H  1 
+#endif
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#ifndef CPPUNIT_HAVE_UNISTD_H 
+#define CPPUNIT_HAVE_UNISTD_H  1 
+#endif
+
+/* Name of package */
+#ifndef CPPUNIT_PACKAGE 
+#define CPPUNIT_PACKAGE  "cppunit" 
+#endif
+
+/* Define to the address where bug reports for this package should be sent. */
+#ifndef CPPUNIT_PACKAGE_BUGREPORT 
+#define CPPUNIT_PACKAGE_BUGREPORT  "" 
+#endif
+
+/* Define to the full name of this package. */
+#ifndef CPPUNIT_PACKAGE_NAME 
+#define CPPUNIT_PACKAGE_NAME  "" 
+#endif
+
+/* Define to the full name and version of this package. */
+#ifndef CPPUNIT_PACKAGE_STRING 
+#define CPPUNIT_PACKAGE_STRING  "" 
+#endif
+
+/* Define to the one symbol short name of this package. */
+#ifndef CPPUNIT_PACKAGE_TARNAME 
+#define CPPUNIT_PACKAGE_TARNAME  "" 
+#endif
+
+/* Define to the version of this package. */
+#ifndef CPPUNIT_PACKAGE_VERSION 
+#define CPPUNIT_PACKAGE_VERSION  "" 
+#endif
+
+/* Define to 1 if you have the ANSI C header files. */
+#ifndef CPPUNIT_STDC_HEADERS 
+#define CPPUNIT_STDC_HEADERS  1 
+#endif
+
+/* Define to 1 to use type_info::name() for class names */
+#ifndef CPPUNIT_USE_TYPEINFO_NAME 
+#define CPPUNIT_USE_TYPEINFO_NAME  CPPUNIT_HAVE_RTTI 
+#endif
+
+/* Version number of package */
+#ifndef CPPUNIT_VERSION 
+#define CPPUNIT_VERSION  "1.12.0" 
+#endif
+ 
+/* _INCLUDE_CPPUNIT_CONFIG_AUTO_H */
+#endif
diff --git a/3rdParty/CppUnit/src/include/cppunit/config/CppUnitApi.h b/3rdParty/CppUnit/src/include/cppunit/config/CppUnitApi.h
new file mode 100644
index 0000000..a068bbd
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/config/CppUnitApi.h
@@ -0,0 +1,33 @@
+#ifndef CPPUNIT_CONFIG_CPPUNITAPI
+#define CPPUNIT_CONFIG_CPPUNITAPI
+
+#undef CPPUNIT_API
+
+#ifdef WIN32
+
+// define CPPUNIT_DLL_BUILD when building CppUnit dll.
+#ifdef CPPUNIT_BUILD_DLL
+#define CPPUNIT_API __declspec(dllexport)
+#endif
+
+// define CPPUNIT_DLL when linking to CppUnit dll.
+#ifdef CPPUNIT_DLL
+#define CPPUNIT_API __declspec(dllimport)
+#endif
+
+#ifdef CPPUNIT_API
+#undef CPPUNIT_NEED_DLL_DECL
+#define CPPUNIT_NEED_DLL_DECL 1
+#endif
+
+#endif
+
+
+#ifndef CPPUNIT_API
+#define CPPUNIT_API
+#undef CPPUNIT_NEED_DLL_DECL
+#define CPPUNIT_NEED_DLL_DECL 0
+#endif
+
+ 
+#endif  // CPPUNIT_CONFIG_CPPUNITAPI
diff --git a/3rdParty/CppUnit/src/include/cppunit/config/SelectDllLoader.h b/3rdParty/CppUnit/src/include/cppunit/config/SelectDllLoader.h
new file mode 100644
index 0000000..dc1c011
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/config/SelectDllLoader.h
@@ -0,0 +1,76 @@
+#ifndef CPPUNIT_CONFIG_SELECTDLLLOADER_H
+#define CPPUNIT_CONFIG_SELECTDLLLOADER_H
+
+/*! \file
+ * Selects DynamicLibraryManager implementation.
+ *
+ * Don't include this file directly. Include Portability.h instead.
+ */
+
+/*!
+ * \def CPPUNIT_NO_TESTPLUGIN
+ * \brief If defined, then plug-in related classes and functions will not be compiled.
+ * 
+ * \internal
+ * CPPUNIT_HAVE_WIN32_DLL_LOADER
+ * If defined, Win32 implementation of DynamicLibraryManager will be used.
+ * 
+ * CPPUNIT_HAVE_BEOS_DLL_LOADER
+ * If defined, BeOs implementation of DynamicLibraryManager will be used.
+ * 
+ * CPPUNIT_HAVE_UNIX_DLL_LOADER
+ * If defined, Unix implementation (dlfcn.h) of DynamicLibraryManager will be used.
+ */
+
+/*!
+ * \def CPPUNIT_PLUGIN_EXPORT
+ * \ingroup WritingTestPlugIn
+ * \brief A macro to export a function from a dynamic library
+ *
+ * This macro export the C function following it from a dynamic library. 
+ * Exporting the function makes it accessible to the DynamicLibraryManager.
+ *
+ * Example of usage:
+ * \code
+ * #include <cppunit/include/plugin/TestPlugIn.h>
+ *
+ * CPPUNIT_PLUGIN_EXPORT CppUnitTestPlugIn *CPPUNIT_PLUGIN_EXPORTED_NAME(void)
+ * {
+ *   ...
+ *   return &myPlugInInterface;
+ * }
+ * \endcode
+ */
+
+#if !defined(CPPUNIT_NO_TESTPLUGIN)
+
+// Is WIN32 platform ?
+#if defined(WIN32)
+#define CPPUNIT_HAVE_WIN32_DLL_LOADER 1
+#undef CPPUNIT_PLUGIN_EXPORT
+#define CPPUNIT_PLUGIN_EXPORT extern "C" __declspec(dllexport)
+
+// Is BeOS platform ?
+#elif defined(__BEOS__)
+#define CPPUNIT_HAVE_BEOS_DLL_LOADER 1
+
+// Is Unix platform and have shl_load() (hp-ux)
+#elif defined(CPPUNIT_HAVE_SHL_LOAD)
+#define CPPUNIT_HAVE_UNIX_SHL_LOADER 1
+
+// Is Unix platform and have include <dlfcn.h>
+#elif defined(CPPUNIT_HAVE_LIBDL)
+#define CPPUNIT_HAVE_UNIX_DLL_LOADER 1
+
+// Otherwise, disable support for DllLoader
+#else
+#define CPPUNIT_NO_TESTPLUGIN 1
+#endif
+
+#if !defined(CPPUNIT_PLUGIN_EXPORT)
+#define CPPUNIT_PLUGIN_EXPORT extern "C"
+#endif // !defined(CPPUNIT_PLUGIN_EXPORT)
+
+#endif // !defined(CPPUNIT_NO_TESTPLUGIN)
+
+#endif // CPPUNIT_CONFIG_SELECTDLLLOADER_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/config/SourcePrefix.h b/3rdParty/CppUnit/src/include/cppunit/config/SourcePrefix.h
new file mode 100644
index 0000000..2334601
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/config/SourcePrefix.h
@@ -0,0 +1,14 @@
+#ifndef CPPUNIT_CONFIG_H_INCLUDED
+#define CPPUNIT_CONFIG_H_INCLUDED
+
+#include <cppunit/Portability.h>
+
+#ifdef _MSC_VER
+#pragma warning(disable: 4018 4284 4146)
+#if _MSC_VER >= 1400
+#pragma warning(disable: 4996)		// sprintf is deprecated
+#endif
+#endif
+
+
+#endif // CPPUNIT_CONFIG_H_INCLUDED
diff --git a/3rdParty/CppUnit/src/include/cppunit/config/config-msvc6.h b/3rdParty/CppUnit/src/include/cppunit/config/config-msvc6.h
new file mode 100644
index 0000000..d688171
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/config/config-msvc6.h
@@ -0,0 +1,83 @@
+#ifndef _INCLUDE_CPPUNIT_CONFIG_MSVC6_H
+#define _INCLUDE_CPPUNIT_CONFIG_MSVC6_H 1
+
+#if _MSC_VER > 1000     // VC++
+#pragma warning( disable : 4786 )   // disable warning debug symbol > 255...
+#endif // _MSC_VER > 1000
+
+#define HAVE_CMATH 1
+ 
+/* include/cppunit/config-msvc6.h. Manually adapted from 
+   include/cppunit/config-auto.h */
+
+/* define to 1 if the compiler implements namespaces */
+#ifndef CPPUNIT_HAVE_NAMESPACES 
+#define CPPUNIT_HAVE_NAMESPACES  1 
+#endif
+
+/* define if library uses std::string::compare(string,pos,n) */
+#ifdef CPPUNIT_FUNC_STRING_COMPARE_STRING_FIRST 
+#undef CPPUNIT_FUNC_STRING_COMPARE_STRING_FIRST
+#endif
+
+/* Define if you have the <dlfcn.h> header file. */
+#ifdef CPPUNIT_HAVE_DLFCN_H 
+#undef CPPUNIT_HAVE_DLFCN_H 
+#endif
+
+/* define to 1 if the compiler implements namespaces */
+#ifndef CPPUNIT_HAVE_NAMESPACES 
+#define CPPUNIT_HAVE_NAMESPACES  1 
+#endif
+
+/* define if the compiler supports Run-Time Type Identification */
+#ifndef CPPUNIT_HAVE_RTTI
+# ifdef _CPPRTTI // Defined by the compiler option /GR
+#  define CPPUNIT_HAVE_RTTI 1
+# else
+#  define CPPUNIT_HAVE_RTTI 0
+# endif
+#endif
+
+/* Define to 1 to use type_info::name() for class names */
+#ifndef CPPUNIT_USE_TYPEINFO_NAME 
+#define CPPUNIT_USE_TYPEINFO_NAME  CPPUNIT_HAVE_RTTI 
+#endif
+
+#define CPPUNIT_HAVE_SSTREAM 1
+
+/* Name of package */
+#ifndef CPPUNIT_PACKAGE 
+#define CPPUNIT_PACKAGE  "cppunit" 
+#endif
+
+
+// Compiler error location format for CompilerOutputter
+// See class CompilerOutputter for format.
+#undef CPPUNIT_COMPILER_LOCATION_FORMAT
+#if _MSC_VER >= 1300    // VS 7.0
+# define CPPUNIT_COMPILER_LOCATION_FORMAT "%p(%l) : error : "
+#else
+# define CPPUNIT_COMPILER_LOCATION_FORMAT "%p(%l):"
+#endif
+
+// Define to 1 if the compiler support C++ style cast.
+#define CPPUNIT_HAVE_CPP_CAST 1
+
+/* define to 1 if the compiler has _finite() */
+#ifndef CPPUNIT_HAVE__FINITE
+#define CPPUNIT_HAVE__FINITE 1 
+#endif
+
+
+// Uncomment to turn on STL wrapping => use this to test compilation. 
+// This will make CppUnit subclass std::vector & co to provide default
+// parameter.
+/*#define CPPUNIT_STD_NEED_ALLOCATOR 1
+#define CPPUNIT_STD_ALLOCATOR std::allocator<T>
+//#define CPPUNIT_NO_NAMESPACE 1
+*/
+
+
+/* _INCLUDE_CPPUNIT_CONFIG_MSVC6_H */
+#endif
diff --git a/3rdParty/CppUnit/src/include/cppunit/extensions/AutoRegisterSuite.h b/3rdParty/CppUnit/src/include/cppunit/extensions/AutoRegisterSuite.h
new file mode 100644
index 0000000..e04adb5
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/extensions/AutoRegisterSuite.h
@@ -0,0 +1,83 @@
+#ifndef CPPUNIT_EXTENSIONS_AUTOREGISTERSUITE_H
+#define CPPUNIT_EXTENSIONS_AUTOREGISTERSUITE_H
+
+#include <cppunit/extensions/TestSuiteFactory.h>
+#include <cppunit/extensions/TestFactoryRegistry.h>
+#include <string>
+
+CPPUNIT_NS_BEGIN
+
+
+/*! \brief (Implementation) Automatically register the test suite of the specified type.
+ *
+ * You should not use this class directly. Instead, use the following macros:
+ * - CPPUNIT_TEST_SUITE_REGISTRATION()
+ * - CPPUNIT_TEST_SUITE_NAMED_REGISTRATION()
+ *
+ * This object will register the test returned by TestCaseType::suite()
+ * when constructed to the test registry.
+ *
+ * This object is intented to be used as a static variable.
+ *
+ *
+ * \param TestCaseType Type of the test case which suite is registered.
+ * \see CPPUNIT_TEST_SUITE_REGISTRATION, CPPUNIT_TEST_SUITE_NAMED_REGISTRATION
+ * \see CppUnit::TestFactoryRegistry.
+ */
+template<class TestCaseType>
+class AutoRegisterSuite
+{
+public:
+  /** Auto-register the suite factory in the global registry.
+   */
+  AutoRegisterSuite()
+      : m_registry( &TestFactoryRegistry::getRegistry() )
+  {
+    m_registry->registerFactory( &m_factory );
+  }
+
+  /** Auto-register the suite factory in the specified registry.
+   * \param name Name of the registry.
+   */
+  AutoRegisterSuite( const std::string &name )
+      : m_registry( &TestFactoryRegistry::getRegistry( name ) )
+  {
+    m_registry->registerFactory( &m_factory );
+  }
+
+  ~AutoRegisterSuite()
+  {
+    if ( TestFactoryRegistry::isValid() )
+      m_registry->unregisterFactory( &m_factory );
+  }
+
+private:
+  TestFactoryRegistry *m_registry;
+  TestSuiteFactory<TestCaseType> m_factory;
+};
+
+
+/*! \brief (Implementation) Automatically adds a registry into another registry.
+ *
+ * Don't use this class. Use the macros CPPUNIT_REGISTRY_ADD() and
+ * CPPUNIT_REGISTRY_ADD_TO_DEFAULT() instead.
+ */
+class AutoRegisterRegistry
+{
+public:
+  AutoRegisterRegistry( const std::string &which,
+                        const std::string &to )
+  {
+    TestFactoryRegistry::getRegistry( to ).addRegistry( which );
+  }
+
+  AutoRegisterRegistry( const std::string &which )
+  {
+    TestFactoryRegistry::getRegistry().addRegistry( which );
+  }
+};
+
+
+CPPUNIT_NS_END
+
+#endif  // CPPUNIT_EXTENSIONS_AUTOREGISTERSUITE_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/extensions/ExceptionTestCaseDecorator.h b/3rdParty/CppUnit/src/include/cppunit/extensions/ExceptionTestCaseDecorator.h
new file mode 100644
index 0000000..9c816ad
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/extensions/ExceptionTestCaseDecorator.h
@@ -0,0 +1,104 @@
+#ifndef CPPUNIT_EXTENSIONS_EXCEPTIONTESTCASEDECORATOR_H
+#define CPPUNIT_EXTENSIONS_EXCEPTIONTESTCASEDECORATOR_H
+
+#include <cppunit/Portability.h>
+#include <cppunit/Exception.h>
+#include <cppunit/extensions/TestCaseDecorator.h>
+
+CPPUNIT_NS_BEGIN
+
+
+/*! \brief Expected exception test case decorator.
+ *
+ * A decorator used to assert that a specific test case should throw an
+ * exception of a given type.
+ *
+ * You should use this class only if you need to check the exception object
+ * state (that a specific cause is set for example). If you don't need to
+ * do that, you might consider using CPPUNIT_TEST_EXCEPTION() instead.
+ *
+ * Intended use is to subclass and override checkException(). Example:
+ *
+ * \code
+ *
+ * class NetworkErrorTestCaseDecorator : 
+ *           public ExceptionTestCaseDecorator<NetworkError>
+ * {
+ * public:
+ *   NetworkErrorTestCaseDecorator( NetworkError::Cause expectedCause )
+ *       : m_expectedCause( expectedCause )
+ *   {
+ *   }
+ * private:
+ *   void checkException( ExpectedExceptionType &e )
+ *   {
+ *     CPPUNIT_ASSERT_EQUAL( m_expectedCause, e.getCause() );
+ *   }
+ *
+ *   NetworkError::Cause m_expectedCause;
+ * };
+ * \endcode
+ *
+ */ 
+template<class ExpectedException>
+class ExceptionTestCaseDecorator : public TestCaseDecorator
+{
+public:
+  typedef ExpectedException ExpectedExceptionType;
+
+  /*! \brief Decorates the specified test.
+   * \param test TestCase to decorate. Assumes ownership of the test.
+   */
+  ExceptionTestCaseDecorator( TestCase *test )
+      : TestCaseDecorator( test )
+  {
+  }
+
+  /*! \brief Checks that the expected exception is thrown by the decorated test.
+   * is thrown.
+   *
+   * Calls the decorated test runTest() and checks that an exception of
+   * type ExpectedException is thrown. Call checkException() passing the
+   * exception that was caught so that some assertions can be made if
+   * needed.
+   */
+  void runTest()
+  {
+    try
+    {
+      TestCaseDecorator::runTest();
+    }
+    catch ( ExpectedExceptionType &e )
+    {
+      checkException( e );
+      return;
+    }
+
+    // Moved outside the try{} statement to handle the case where the
+    // expected exception type is Exception (expecting assertion failure).
+#if CPPUNIT_USE_TYPEINFO_NAME
+      throw Exception( Message(
+                         "expected exception not thrown",
+                         "Expected exception type: " + 
+                           TypeInfoHelper::getClassName( 
+                               typeid( ExpectedExceptionType ) ) ) );
+#else
+      throw Exception( Message("expected exception not thrown") );
+#endif
+  }
+
+private:
+  /*! \brief Called when the exception is caught.
+   *
+   * Should be overriden to check the exception.
+   */
+  virtual void checkException( ExpectedExceptionType &e )
+  {
+  }
+};
+
+
+CPPUNIT_NS_END
+
+#endif // CPPUNIT_EXTENSIONS_EXCEPTIONTESTCASEDECORATOR_H
+
diff --git a/3rdParty/CppUnit/src/include/cppunit/extensions/HelperMacros.h b/3rdParty/CppUnit/src/include/cppunit/extensions/HelperMacros.h
new file mode 100644
index 0000000..12431e4
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/extensions/HelperMacros.h
@@ -0,0 +1,541 @@
+// //////////////////////////////////////////////////////////////////////////
+// Header file HelperMacros.h
+// (c)Copyright 2000, Baptiste Lepilleur.
+// Created: 2001/04/15
+// //////////////////////////////////////////////////////////////////////////
+#ifndef CPPUNIT_EXTENSIONS_HELPERMACROS_H
+#define CPPUNIT_EXTENSIONS_HELPERMACROS_H
+
+#include <cppunit/TestCaller.h>
+#include <cppunit/TestSuite.h>
+#include <cppunit/extensions/AutoRegisterSuite.h>
+#include <cppunit/extensions/ExceptionTestCaseDecorator.h>
+#include <cppunit/extensions/TestFixtureFactory.h>
+#include <cppunit/extensions/TestNamer.h>
+#include <cppunit/extensions/TestSuiteBuilderContext.h>
+#include <memory>
+
+
+/*! \addtogroup WritingTestFixture Writing test fixture
+ */
+/** @{
+ */
+
+
+/** \file
+ * Macros intended to ease the definition of test suites.
+ *
+ * The macros
+ * CPPUNIT_TEST_SUITE(), CPPUNIT_TEST(), and CPPUNIT_TEST_SUITE_END()
+ * are designed to facilitate easy creation of a test suite.
+ * For example,
+ *
+ * \code
+ * #include <cppunit/extensions/HelperMacros.h>
+ * class MyTest : public CppUnit::TestFixture {
+ *   CPPUNIT_TEST_SUITE( MyTest );
+ *   CPPUNIT_TEST( testEquality );
+ *   CPPUNIT_TEST( testSetName );
+ *   CPPUNIT_TEST_SUITE_END();
+ * public:
+ *   void testEquality();
+ *   void testSetName();
+ * };
+ * \endcode
+ * 
+ * The effect of these macros is to define two methods in the
+ * class MyTest.  The first method is an auxiliary function
+ * named registerTests that you will not need to call directly.
+ * The second function
+ * \code static CppUnit::TestSuite *suite()\endcode
+ * returns a pointer to the suite of tests defined by the CPPUNIT_TEST()
+ * macros.  
+ *
+ * Rather than invoking suite() directly,
+ * the macro CPPUNIT_TEST_SUITE_REGISTRATION() is
+ * used to create a static variable that automatically
+ * registers its test suite in a global registry.
+ * The registry yields a Test instance containing all the
+ * registered suites.
+ * \code
+ * CPPUNIT_TEST_SUITE_REGISTRATION( MyTest );
+ * CppUnit::Test* tp =
+ *   CppUnit::TestFactoryRegistry::getRegistry().makeTest();
+ * \endcode
+ * 
+ * The test suite macros can even be used with templated test classes.
+ * For example:
+ *
+ * \code
+ * template<typename CharType>
+ * class StringTest : public CppUnit::TestFixture {
+ *   CPPUNIT_TEST_SUITE( StringTest );
+ *   CPPUNIT_TEST( testAppend );
+ *   CPPUNIT_TEST_SUITE_END();
+ * public:  
+ *   ...
+ * };
+ * \endcode
+ *
+ * You need to add in an implementation file:
+ *
+ * \code
+ * CPPUNIT_TEST_SUITE_REGISTRATION( StringTest<char> );
+ * CPPUNIT_TEST_SUITE_REGISTRATION( StringTest<wchar_t> );
+ * \endcode
+ */
+
+
+/*! \brief Begin test suite
+ *
+ * This macro starts the declaration of a new test suite.
+ * Use CPPUNIT_TEST_SUB_SUITE() instead, if you wish to include the
+ * test suite of the parent class.
+ *
+ * \param ATestFixtureType Type of the test case class. This type \b MUST
+ *                         be derived from TestFixture.
+ * \see CPPUNIT_TEST_SUB_SUITE, CPPUNIT_TEST, CPPUNIT_TEST_SUITE_END, 
+ * \see CPPUNIT_TEST_SUITE_REGISTRATION, CPPUNIT_TEST_EXCEPTION, CPPUNIT_TEST_FAIL.
+ */
+#define CPPUNIT_TEST_SUITE( ATestFixtureType )                              \
+  public:                                                                   \
+    typedef ATestFixtureType TestFixtureType;                               \
+                                                                            \
+  private:                                                                  \
+    static const CPPUNIT_NS::TestNamer &getTestNamer__()                    \
+    {                                                                       \
+      static CPPUNIT_TESTNAMER_DECL( testNamer, ATestFixtureType );         \
+      return testNamer;                                                     \
+    }                                                                       \
+                                                                            \
+  public:                                                                   \
+    typedef CPPUNIT_NS::TestSuiteBuilderContext<TestFixtureType>            \
+                TestSuiteBuilderContextType;                                \
+                                                                            \
+    static void                                                             \
+    addTestsToSuite( CPPUNIT_NS::TestSuiteBuilderContextBase &baseContext ) \
+    {                                                                       \
+      TestSuiteBuilderContextType context( baseContext )
+
+
+/*! \brief Begin test suite (includes parent suite)
+ * 
+ * This macro may only be used in a class whose parent class
+ * defines a test suite using CPPUNIT_TEST_SUITE() or CPPUNIT_TEST_SUB_SUITE().
+ *
+ * This macro begins the declaration of a test suite, in the same
+ * manner as CPPUNIT_TEST_SUITE().  In addition, the test suite of the
+ * parent is automatically inserted in the test suite being
+ * defined.
+ * 
+ * Here is an example:
+ *
+ * \code
+ * #include <cppunit/extensions/HelperMacros.h>
+ * class MySubTest : public MyTest {
+ *   CPPUNIT_TEST_SUB_SUITE( MySubTest, MyTest );
+ *   CPPUNIT_TEST( testAdd );
+ *   CPPUNIT_TEST( testSub );
+ *   CPPUNIT_TEST_SUITE_END();
+ * public:
+ *   void testAdd();
+ *   void testSub();
+ * };
+ * \endcode
+ *
+ * \param ATestFixtureType Type of the test case class. This type \b MUST
+ *                         be derived from TestFixture.
+ * \param ASuperClass   Type of the parent class.
+ * \see CPPUNIT_TEST_SUITE.
+ */
+#define CPPUNIT_TEST_SUB_SUITE( ATestFixtureType, ASuperClass )  \
+  public:                                                        \
+    typedef ASuperClass ParentTestFixtureType;                   \
+  private:                                                       \
+    CPPUNIT_TEST_SUITE( ATestFixtureType );                      \
+      ParentTestFixtureType::addTestsToSuite( baseContext )
+
+
+/*! \brief End declaration of the test suite.
+ *
+ * After this macro, member access is set to "private".
+ *
+ * \see  CPPUNIT_TEST_SUITE.
+ * \see  CPPUNIT_TEST_SUITE_REGISTRATION.
+ */
+#define CPPUNIT_TEST_SUITE_END()                                               \
+    }                                                                          \
+                                                                               \
+    static CPPUNIT_NS::TestSuite *suite()                                      \
+    {                                                                          \
+      const CPPUNIT_NS::TestNamer &namer = getTestNamer__();                   \
+      std::auto_ptr<CPPUNIT_NS::TestSuite> suite(                              \
+             new CPPUNIT_NS::TestSuite( namer.getFixtureName() ));             \
+      CPPUNIT_NS::ConcretTestFixtureFactory<TestFixtureType> factory;          \
+      CPPUNIT_NS::TestSuiteBuilderContextBase context( *suite.get(),           \
+                                                       namer,                  \
+                                                       factory );              \
+      TestFixtureType::addTestsToSuite( context );                             \
+      return suite.release();                                                  \
+    }                                                                          \
+  private: /* dummy typedef so that the macro can still end with ';'*/         \
+    typedef int CppUnitDummyTypedefForSemiColonEnding__
+
+/*! \brief End declaration of an abstract test suite.
+ *
+ * Use this macro to indicate that the %TestFixture is abstract. No
+ * static suite() method will be declared. 
+ *
+ * After this macro, member access is set to "private".
+ *
+ * Here is an example of usage:
+ *
+ * The abstract test fixture:
+ * \code
+ * #include <cppunit/extensions/HelperMacros.h>
+ * class AbstractDocument;
+ * class AbstractDocumentTest : public CppUnit::TestFixture {
+ *   CPPUNIT_TEST_SUITE( AbstractDocumentTest );
+ *   CPPUNIT_TEST( testInsertText );
+ *   CPPUNIT_TEST_SUITE_END_ABSTRACT();
+ * public:
+ *   void testInsertText();
+ * 
+ *   void setUp()
+ *   {
+ *     m_document = makeDocument();
+ *   }
+ *
+ *   void tearDown()
+ *   {
+ *     delete m_document;
+ *   }
+ * protected:
+ *   virtual AbstractDocument *makeDocument() =0;
+ *
+ *   AbstractDocument *m_document;
+ * };\endcode
+ *
+ * The concret test fixture:
+ * \code
+ * class RichTextDocumentTest : public AbstractDocumentTest {
+ *   CPPUNIT_TEST_SUB_SUITE( RichTextDocumentTest, AbstractDocumentTest );
+ *   CPPUNIT_TEST( testInsertFormatedText );
+ *   CPPUNIT_TEST_SUITE_END();
+ * public:
+ *   void testInsertFormatedText();
+ * protected:
+ *   AbstractDocument *makeDocument()
+ *   {
+ *     return new RichTextDocument();
+ *   }
+ * };\endcode
+ *
+ * \see  CPPUNIT_TEST_SUB_SUITE.
+ * \see  CPPUNIT_TEST_SUITE_REGISTRATION.
+ */
+#define CPPUNIT_TEST_SUITE_END_ABSTRACT()                                      \
+    }                                                                          \
+  private: /* dummy typedef so that the macro can still end with ';'*/         \
+    typedef int CppUnitDummyTypedefForSemiColonEnding__
+
+
+/*! \brief Add a test to the suite (for custom test macro).
+ *
+ * The specified test will be added to the test suite being declared. This macro
+ * is intended for \e advanced usage, to extend %CppUnit by creating new macro such
+ * as CPPUNIT_TEST_EXCEPTION()...
+ *
+ * Between macro CPPUNIT_TEST_SUITE() and CPPUNIT_TEST_SUITE_END(), you can assume
+ * that the following variables can be used:
+ * \code
+ * typedef TestSuiteBuilder<TestFixtureType> TestSuiteBuilderType;
+ * TestSuiteBuilderType &context;
+ * \endcode
+ *
+ * \c context can be used to name test case, create new test fixture instance,
+ * or add test case to the test fixture suite.
+ *
+ * Below is an example that show how to use this macro to create new macro to add
+ * test to the fixture suite. The macro below show how you would add a new type
+ * of test case which fails if the execution last more than a given time limit.
+ * It relies on an imaginary TimeOutTestCaller class which has an interface similar
+ * to TestCaller.
+ * 
+ * \code
+ * #define CPPUNITEX_TEST_TIMELIMIT( testMethod, timeLimit )            \
+ *      CPPUNIT_TEST_SUITE_ADD_TEST( (new TimeOutTestCaller<TestFixtureType>(  \
+ *                  namer.getTestNameFor( #testMethod ),                \
+ *                  &TestFixtureType::testMethod,                   \
+ *                  factory.makeFixture(),                              \
+ *                  timeLimit ) ) )
+ *   
+ * class PerformanceTest : CppUnit::TestFixture
+ * {
+ * public:
+ *   CPPUNIT_TEST_SUITE( PerformanceTest );
+ *   CPPUNITEX_TEST_TIMELIMIT( testSortReverseOrder, 5.0 );
+ *   CPPUNIT_TEST_SUITE_END();
+ *
+ *   void testSortReverseOrder();
+ * };
+ * \endcode
+ *
+ * \param test Test to add to the suite. Must be a subclass of Test. The test name
+ *             should have been obtained using TestNamer::getTestNameFor().
+ */
+#define CPPUNIT_TEST_SUITE_ADD_TEST( test ) \
+      context.addTest( test )
+
+/*! \brief Add a method to the suite.
+ * \param testMethod Name of the method of the test case to add to the
+ *                   suite. The signature of the method must be of
+ *                   type: void testMethod();
+ * \see  CPPUNIT_TEST_SUITE.
+ */
+#define CPPUNIT_TEST( testMethod )                        \
+    CPPUNIT_TEST_SUITE_ADD_TEST(                           \
+        ( new CPPUNIT_NS::TestCaller<TestFixtureType>(    \
+                  context.getTestNameFor( #testMethod),   \
+                  &TestFixtureType::testMethod,           \
+                  context.makeFixture() ) ) )
+
+/*! \brief Add a test which fail if the specified exception is not caught.
+ *
+ * Example:
+ * \code
+ * #include <cppunit/extensions/HelperMacros.h>
+ * #include <vector>
+ * class MyTest : public CppUnit::TestFixture {
+ *   CPPUNIT_TEST_SUITE( MyTest );
+ *   CPPUNIT_TEST_EXCEPTION( testVectorAtThrow, std::invalid_argument );
+ *   CPPUNIT_TEST_SUITE_END();
+ * public:
+ *   void testVectorAtThrow()
+ *   {
+ *     std::vector<int> v;
+ *     v.at( 1 );     // must throw exception std::invalid_argument
+ *   }
+ * };
+ * \endcode
+ *
+ * \param testMethod Name of the method of the test case to add to the suite.
+ * \param ExceptionType Type of the exception that must be thrown by the test 
+ *                      method.
+ * \deprecated Use the assertion macro CPPUNIT_ASSERT_THROW instead.
+ */
+#define CPPUNIT_TEST_EXCEPTION( testMethod, ExceptionType )          \
+  CPPUNIT_TEST_SUITE_ADD_TEST(                                        \
+      (new CPPUNIT_NS::ExceptionTestCaseDecorator< ExceptionType >(  \
+          new CPPUNIT_NS::TestCaller< TestFixtureType >(             \
+                               context.getTestNameFor( #testMethod ),  \
+                               &TestFixtureType::testMethod,         \
+                               context.makeFixture() ) ) ) )
+
+/*! \brief Adds a test case which is excepted to fail.
+ *
+ * The added test case expect an assertion to fail. You usually used that type
+ * of test case when testing custom assertion macros.
+ *
+ * \code
+ * CPPUNIT_TEST_FAIL( testAssertFalseFail );
+ * 
+ * void testAssertFalseFail()
+ * {
+ *   CPPUNIT_ASSERT( false );
+ * }
+ * \endcode
+ * \see CreatingNewAssertions.
+ * \deprecated Use the assertion macro CPPUNIT_ASSERT_ASSERTION_FAIL instead.
+ */
+#define CPPUNIT_TEST_FAIL( testMethod ) \
+              CPPUNIT_TEST_EXCEPTION( testMethod, CPPUNIT_NS::Exception )
+
+/*! \brief Adds some custom test cases.
+ *
+ * Use this to add one or more test cases to the fixture suite. The specified
+ * method is called with a context parameter that can be used to name, 
+ * instantiate fixture, and add instantiated test case to the fixture suite.
+ * The specified method must have the following signature:
+ * \code
+ * static void aMethodName( TestSuiteBuilderContextType &context );
+ * \endcode
+ *
+ * \c TestSuiteBuilderContextType is typedef to 
+ * TestSuiteBuilderContext<TestFixtureType> declared by CPPUNIT_TEST_SUITE().
+ *
+ * Here is an example that add two custom tests:
+ *
+ * \code
+ * #include <cppunit/extensions/HelperMacros.h>
+ *
+ * class MyTest : public CppUnit::TestFixture {
+ *   CPPUNIT_TEST_SUITE( MyTest );
+ *   CPPUNIT_TEST_SUITE_ADD_CUSTOM_TESTS( addTimeOutTests );
+ *   CPPUNIT_TEST_SUITE_END();
+ * public:
+ *   static void addTimeOutTests( TestSuiteBuilderContextType &context )
+ *   {
+ *     context.addTest( new TimeOutTestCaller( context.getTestNameFor( "test1" ) ),
+ *                                             &MyTest::test1,
+ *                                             context.makeFixture(),
+ *                                             5.0 );
+ *     context.addTest( new TimeOutTestCaller( context.getTestNameFor( "test2" ) ),
+ *                                             &MyTest::test2,
+ *                                             context.makeFixture(),
+ *                                             5.0 );
+ *   }
+ *
+ *   void test1()
+ *   {
+ *     // Do some test that may never end...
+ *   }
+ *
+ *   void test2()
+ *   {
+ *     // Do some test that may never end...
+ *   }
+ * };
+ * \endcode
+ * @param testAdderMethod Name of the method called to add the test cases.
+ */
+#define CPPUNIT_TEST_SUITE_ADD_CUSTOM_TESTS( testAdderMethod ) \
+      testAdderMethod( context )
+
+/*! \brief Adds a property to the test suite builder context.
+ * \param APropertyKey   Key of the property to add.
+ * \param APropertyValue Value for the added property.
+ * Example:
+ * \code
+ * CPPUNIT_TEST_SUITE_PROPERTY("XmlFileName", "paraTest.xml"); \endcode
+ */
+#define CPPUNIT_TEST_SUITE_PROPERTY( APropertyKey, APropertyValue ) \
+    context.addProperty( std::string(APropertyKey),                 \
+                         std::string(APropertyValue) )
+
+/** @}
+ */
+
+
+/*! Adds the specified fixture suite to the unnamed registry.
+ * \ingroup CreatingTestSuite
+ *
+ * This macro declares a static variable whose construction
+ * causes a test suite factory to be inserted in a global registry
+ * of such factories.  The registry is available by calling
+ * the static function CppUnit::TestFactoryRegistry::getRegistry().
+ * 
+ * \param ATestFixtureType Type of the test case class.
+ * \warning This macro should be used only once per line of code (the line
+ *          number is used to name a hidden static variable).
+ * \see CPPUNIT_TEST_SUITE_NAMED_REGISTRATION
+ * \see CPPUNIT_REGISTRY_ADD_TO_DEFAULT
+ * \see CPPUNIT_REGISTRY_ADD
+ * \see CPPUNIT_TEST_SUITE, CppUnit::AutoRegisterSuite, 
+ *      CppUnit::TestFactoryRegistry.
+ */
+#define CPPUNIT_TEST_SUITE_REGISTRATION( ATestFixtureType )      \
+  static CPPUNIT_NS::AutoRegisterSuite< ATestFixtureType >       \
+             CPPUNIT_MAKE_UNIQUE_NAME(autoRegisterRegistry__ )
+
+
+/** Adds the specified fixture suite to the specified registry suite.
+ * \ingroup CreatingTestSuite
+ *
+ * This macro declares a static variable whose construction
+ * causes a test suite factory to be inserted in the global registry
+ * suite of the specified name. The registry is available by calling
+ * the static function CppUnit::TestFactoryRegistry::getRegistry().
+ * 
+ * For the suite name, use a string returned by a static function rather
+ * than a hardcoded string. That way, you can know what are the name of
+ * named registry and you don't risk mistyping the registry name.
+ *
+ * \code
+ * // MySuites.h
+ * namespace MySuites {
+ *   std::string math() { 
+ *     return "Math";
+ *   }
+ * }
+ *
+ * // ComplexNumberTest.cpp
+ * #include "MySuites.h"
+ * 
+ * CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( ComplexNumberTest, MySuites::math() );
+ * \endcode
+ *
+ * \param ATestFixtureType Type of the test case class.
+ * \param suiteName Name of the global registry suite the test suite is 
+ *                  registered into.
+ * \warning This macro should be used only once per line of code (the line
+ *          number is used to name a hidden static variable).
+ * \see CPPUNIT_TEST_SUITE_REGISTRATION
+ * \see CPPUNIT_REGISTRY_ADD_TO_DEFAULT
+ * \see CPPUNIT_REGISTRY_ADD
+ * \see CPPUNIT_TEST_SUITE, CppUnit::AutoRegisterSuite, 
+ *      CppUnit::TestFactoryRegistry..
+ */
+#define CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( ATestFixtureType, suiteName ) \
+  static CPPUNIT_NS::AutoRegisterSuite< ATestFixtureType >                   \
+             CPPUNIT_MAKE_UNIQUE_NAME(autoRegisterRegistry__ )(suiteName)
+
+/*! Adds that the specified registry suite to another registry suite.
+ * \ingroup CreatingTestSuite
+ *
+ * Use this macros to automatically create test registry suite hierarchy. For example,
+ * if you want to create the following hierarchy:
+ * - Math
+ *   - IntegerMath
+ *   - FloatMath
+ *     - FastFloat
+ *     - StandardFloat
+ * 
+ * You can do this automatically with:
+ * \code
+ * CPPUNIT_REGISTRY_ADD( "FastFloat", "FloatMath" );
+ * CPPUNIT_REGISTRY_ADD( "IntegerMath", "Math" );
+ * CPPUNIT_REGISTRY_ADD( "FloatMath", "Math" );
+ * CPPUNIT_REGISTRY_ADD( "StandardFloat", "FloatMath" );
+ * \endcode
+ *
+ * There is no specific order of declaration. Think of it as declaring links.
+ *
+ * You register the test in each suite using CPPUNIT_TEST_SUITE_NAMED_REGISTRATION.
+ *
+ * \param which Name of the registry suite to add to the registry suite named \a to.
+ * \param to Name of the registry suite \a which is added to.
+ * \see CPPUNIT_REGISTRY_ADD_TO_DEFAULT, CPPUNIT_TEST_SUITE_NAMED_REGISTRATION.
+ */
+#define CPPUNIT_REGISTRY_ADD( which, to )                                     \
+  static CPPUNIT_NS::AutoRegisterRegistry                                     \
+             CPPUNIT_MAKE_UNIQUE_NAME( autoRegisterRegistry__ )( which, to )
+
+/*! Adds that the specified registry suite to the default registry suite.
+ * \ingroup CreatingTestSuite
+ *
+ * This macro is just like CPPUNIT_REGISTRY_ADD except the specified registry
+ * suite is added to the default suite (root suite).
+ *
+ * \param which Name of the registry suite to add to the default registry suite.
+ * \see CPPUNIT_REGISTRY_ADD.
+ */
+#define CPPUNIT_REGISTRY_ADD_TO_DEFAULT( which )                         \
+  static CPPUNIT_NS::AutoRegisterRegistry                                \
+             CPPUNIT_MAKE_UNIQUE_NAME( autoRegisterRegistry__ )( which )
+
+// Backwards compatibility
+// (Not tested!)
+
+#if CPPUNIT_ENABLE_CU_TEST_MACROS
+
+#define CU_TEST_SUITE(tc) CPPUNIT_TEST_SUITE(tc)
+#define CU_TEST_SUB_SUITE(tc,sc) CPPUNIT_TEST_SUB_SUITE(tc,sc)
+#define CU_TEST(tm) CPPUNIT_TEST(tm)
+#define CU_TEST_SUITE_END() CPPUNIT_TEST_SUITE_END()
+#define CU_TEST_SUITE_REGISTRATION(tc) CPPUNIT_TEST_SUITE_REGISTRATION(tc)
+
+#endif
+
+
+#endif  // CPPUNIT_EXTENSIONS_HELPERMACROS_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/extensions/TestCaseDecorator.h b/3rdParty/CppUnit/src/include/cppunit/extensions/TestCaseDecorator.h
new file mode 100644
index 0000000..3a15ba9
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/extensions/TestCaseDecorator.h
@@ -0,0 +1,40 @@
+#ifndef CPPUNIT_EXTENSIONS_TESTCASEDECORATOR_H
+#define CPPUNIT_EXTENSIONS_TESTCASEDECORATOR_H
+
+#include <cppunit/Portability.h>
+#include <cppunit/TestCase.h>
+
+CPPUNIT_NS_BEGIN
+
+
+/*! \brief  Decorator for Test cases.
+ *
+ * TestCaseDecorator provides an alternate means to extend functionality
+ * of a test class without subclassing the test.  Instead, one can
+ * subclass the decorater and use it to wrap the test class.
+ *
+ * Does not assume ownership of the test it decorates
+ */ 
+class CPPUNIT_API TestCaseDecorator : public TestCase
+{
+public:
+  TestCaseDecorator( TestCase *test );
+  ~TestCaseDecorator();
+
+  std::string getName() const;
+
+  void setUp();
+
+  void tearDown();
+
+  void runTest();
+
+protected:
+  TestCase *m_test;
+};
+
+
+CPPUNIT_NS_END
+
+#endif
+
diff --git a/3rdParty/CppUnit/src/include/cppunit/extensions/TestFactory.h b/3rdParty/CppUnit/src/include/cppunit/extensions/TestFactory.h
new file mode 100644
index 0000000..214d353
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/extensions/TestFactory.h
@@ -0,0 +1,27 @@
+#ifndef CPPUNIT_EXTENSIONS_TESTFACTORY_H
+#define CPPUNIT_EXTENSIONS_TESTFACTORY_H
+
+#include <cppunit/Portability.h>
+
+CPPUNIT_NS_BEGIN
+
+
+class Test;
+
+/*! \brief Abstract Test factory.
+ */
+class CPPUNIT_API TestFactory 
+{
+public:
+  virtual ~TestFactory() {}
+
+  /*! Makes a new test.
+   * \return A new Test.
+   */
+  virtual Test* makeTest() = 0;
+};
+
+
+CPPUNIT_NS_END
+
+#endif  // CPPUNIT_EXTENSIONS_TESTFACTORY_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/extensions/TestFactoryRegistry.h b/3rdParty/CppUnit/src/include/cppunit/extensions/TestFactoryRegistry.h
new file mode 100644
index 0000000..fc8723e
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/extensions/TestFactoryRegistry.h
@@ -0,0 +1,182 @@
+#ifndef CPPUNIT_EXTENSIONS_TESTFACTORYREGISTRY_H
+#define CPPUNIT_EXTENSIONS_TESTFACTORYREGISTRY_H
+
+#include <cppunit/Portability.h>
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( push )
+#pragma warning( disable: 4251)  // X needs to have dll-interface to be used by clients of class Z
+#endif
+
+#include <cppunit/portability/CppUnitSet.h>
+#include <cppunit/extensions/TestFactory.h>
+#include <string>
+
+CPPUNIT_NS_BEGIN
+
+
+class TestSuite;
+
+#if CPPUNIT_NEED_DLL_DECL
+//  template class CPPUNIT_API std::set<TestFactory *>;
+#endif
+
+
+/*! \brief Registry for TestFactory.
+ * \ingroup CreatingTestSuite
+ *
+ * Notes that the registry \b DON'T assumes lifetime control for any registered tests
+ * anymore.
+ *
+ * The <em>default</em> registry is the registry returned by getRegistry() with the 
+ * default name parameter value.
+ *
+ * To register tests, use the macros:
+ * - CPPUNIT_TEST_SUITE_REGISTRATION(): to add tests in the default registry.
+ * - CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(): to add tests in a named registry.
+ *
+ * Example 1: retreiving a suite that contains all the test registered with
+ * CPPUNIT_TEST_SUITE_REGISTRATION().
+ * \code
+ * CppUnit::TestFactoryRegistry &registry = CppUnit::TestFactoryRegistry::getRegistry();
+ * CppUnit::TestSuite *suite = registry.makeTest();
+ * \endcode
+ *
+ * Example 2: retreiving a suite that contains all the test registered with
+ * \link CPPUNIT_TEST_SUITE_NAMED_REGISTRATION() CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( ..., "Math" )\endlink.
+ * \code
+ * CppUnit::TestFactoryRegistry &mathRegistry = CppUnit::TestFactoryRegistry::getRegistry( "Math" );
+ * CppUnit::TestSuite *mathSuite = mathRegistry.makeTest();
+ * \endcode
+ *
+ * Example 3: creating a test suite hierarchy composed of unnamed registration and
+ * named registration:
+ * - All Tests
+ *   - tests registered with CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( ..., "Graph" )
+ *   - tests registered with CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( ..., "Math" )
+ *   - tests registered with CPPUNIT_TEST_SUITE_REGISTRATION
+ *
+ * \code
+ * CppUnit::TestSuite *rootSuite = new CppUnit::TestSuite( "All tests" );
+ * rootSuite->addTest( CppUnit::TestFactoryRegistry::getRegistry( "Graph" ).makeTest() );
+ * rootSuite->addTest( CppUnit::TestFactoryRegistry::getRegistry( "Math" ).makeTest() );
+ * CppUnit::TestFactoryRegistry::getRegistry().addTestToSuite( rootSuite );
+ * \endcode
+ *
+ * The same result can be obtained with:
+ * \code
+ * CppUnit::TestFactoryRegistry &registry = CppUnit::TestFactoryRegistry::getRegistry();
+ * registry.addRegistry( "Graph" );
+ * registry.addRegistry( "Math" );
+ * CppUnit::TestSuite *suite = registry.makeTest();
+ * \endcode
+ *
+ * Since a TestFactoryRegistry is a TestFactory, the named registries can be 
+ * registered in the unnamed registry, creating the hierarchy links.
+ *
+ * \see TestSuiteFactory, AutoRegisterSuite
+ * \see CPPUNIT_TEST_SUITE_REGISTRATION, CPPUNIT_TEST_SUITE_NAMED_REGISTRATION
+ */
+class CPPUNIT_API TestFactoryRegistry : public TestFactory
+{
+public:
+  /** Constructs the registry with the specified name.
+   * \param name Name of the registry. It is the name of TestSuite returned by
+   *             makeTest().
+   */
+  TestFactoryRegistry( std::string name );
+
+  /// Destructor.
+  virtual ~TestFactoryRegistry();
+
+  /** Returns a new TestSuite that contains the registered test.
+   * \return A new TestSuite which contains all the test added using 
+   * registerFactory(TestFactory *).
+   */
+  virtual Test *makeTest();
+
+  /** Returns a named registry.
+   *
+   * If the \a name is left to its default value, then the registry that is returned is
+   * the one used by CPPUNIT_TEST_SUITE_REGISTRATION(): the 'top' level registry.
+   *
+   * \param name Name of the registry to return.
+   * \return Registry. If the registry does not exist, it is created with the
+   *         specified name.
+   */
+  static TestFactoryRegistry &getRegistry( const std::string &name = "All Tests" );
+
+  /** Adds the registered tests to the specified suite.
+   * \param suite Suite the tests are added to.
+   */
+  void addTestToSuite( TestSuite *suite );
+
+  /** Adds the specified TestFactory to the registry.
+   *
+   * \param factory Factory to register. 
+   */
+  void registerFactory( TestFactory *factory );
+
+  /*! Removes the specified TestFactory from the registry.
+   * 
+   * The specified factory is not destroyed.
+   * \param factory Factory to remove from the registry.
+   * \todo Address case when trying to remove a TestRegistryFactory.
+   */
+  void unregisterFactory( TestFactory *factory );
+
+  /*! Adds a registry to the registry.
+   * 
+   * Convenience method to help create test hierarchy. See TestFactoryRegistry detail
+   * for examples of use. Calling this method is equivalent to:
+   * \code
+   * this->registerFactory( TestFactoryRegistry::getRegistry( name ) );
+   * \endcode
+   *
+   * \param name Name of the registry to add.
+   */
+  void addRegistry( const std::string &name );
+
+  /*! Tests if the registry is valid.
+   *
+   * This method should be used when unregistering test factory on static variable 
+   * destruction to ensure that the registry has not been already destroyed (in 
+   * that case there is no need to unregister the test factory).
+   *
+   * You should not concern yourself with this method unless you are writing a class
+   * like AutoRegisterSuite.
+   *
+   * \return \c true if the specified registry has not been destroyed, 
+   *         otherwise returns \c false.
+   * \see AutoRegisterSuite.
+   */
+  static bool isValid();
+
+  /** Adds the specified TestFactory with a specific name (DEPRECATED).
+   * \param name Name associated to the factory.
+   * \param factory Factory to register. 
+   * \deprecated Use registerFactory( TestFactory *) instead.
+   */
+  void registerFactory( const std::string &name,
+                        TestFactory *factory );
+
+private:
+  TestFactoryRegistry( const TestFactoryRegistry &copy );
+  void operator =( const TestFactoryRegistry &copy );
+
+private:
+  typedef CppUnitSet<TestFactory *, std::less<TestFactory*> > Factories;
+  Factories m_factories;
+
+  std::string m_name;
+};
+
+
+CPPUNIT_NS_END
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( pop )
+#endif
+
+
+#endif  // CPPUNIT_EXTENSIONS_TESTFACTORYREGISTRY_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/extensions/TestFixtureFactory.h b/3rdParty/CppUnit/src/include/cppunit/extensions/TestFixtureFactory.h
new file mode 100644
index 0000000..45354c6
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/extensions/TestFixtureFactory.h
@@ -0,0 +1,50 @@
+#ifndef CPPUNIT_EXTENSIONS_TESTFIXTUREFACTORY_H
+#define CPPUNIT_EXTENSIONS_TESTFIXTUREFACTORY_H
+
+#include <cppunit/Portability.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+class TestFixture;
+
+/*! \brief Abstract TestFixture factory (Implementation).
+ *
+ * Implementation detail. Use by HelperMacros to handle TestFixture hierarchy.
+ */
+class TestFixtureFactory
+{
+public:
+  //! Creates a new TestFixture instance.
+  virtual TestFixture *makeFixture() =0;
+
+  virtual ~TestFixtureFactory() {}
+};
+
+
+/*! \brief Concret TestFixture factory (Implementation).
+ *
+ * Implementation detail. Use by HelperMacros to handle TestFixture hierarchy.
+ */
+template<class TestFixtureType>
+class ConcretTestFixtureFactory : public CPPUNIT_NS::TestFixtureFactory
+{
+  /*! \brief Returns a new TestFixture instance.
+   * \return A new fixture instance. The fixture instance is returned by
+   *         the TestFixtureFactory passed on construction. The actual type 
+   *         is that of the fixture on which the static method suite() 
+   *         was called.
+   */
+  TestFixture *makeFixture()
+  {
+    return new TestFixtureType();
+  }
+};
+
+
+CPPUNIT_NS_END
+
+
+#endif // CPPUNIT_EXTENSIONS_TESTFIXTUREFACTORY_H
+
diff --git a/3rdParty/CppUnit/src/include/cppunit/extensions/TestNamer.h b/3rdParty/CppUnit/src/include/cppunit/extensions/TestNamer.h
new file mode 100644
index 0000000..5a6471c
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/extensions/TestNamer.h
@@ -0,0 +1,89 @@
+#ifndef CPPUNIT_EXTENSIONS_TESTNAMER_H
+#define CPPUNIT_EXTENSIONS_TESTNAMER_H
+
+#include <cppunit/Portability.h>
+#include <string>
+
+#if CPPUNIT_HAVE_RTTI
+#  include <typeinfo>
+#endif
+
+
+
+/*! \def CPPUNIT_TESTNAMER_DECL( variableName, FixtureType )
+ * \brief Declares a TestNamer.
+ *
+ * Declares a TestNamer for the specified type, using RTTI if enabled, otherwise
+ * using macro string expansion.
+ *
+ * RTTI is used if CPPUNIT_USE_TYPEINFO_NAME is defined and not null.
+ *
+ * \code
+ * void someMethod() 
+ * {
+ *   CPPUNIT_TESTNAMER_DECL( namer, AFixtureType );
+ *   std::string fixtureName = namer.getFixtureName();
+ *   ...
+ * \endcode
+ *
+ * \relates TestNamer
+ * \see TestNamer
+ */
+#if CPPUNIT_USE_TYPEINFO_NAME
+#  define CPPUNIT_TESTNAMER_DECL( variableName, FixtureType )       \
+              CPPUNIT_NS::TestNamer variableName( typeid(FixtureType) )
+#else
+#  define CPPUNIT_TESTNAMER_DECL( variableName, FixtureType )       \
+              CPPUNIT_NS::TestNamer variableName( std::string(#FixtureType) )
+#endif
+
+
+
+CPPUNIT_NS_BEGIN
+
+
+/*! \brief Names a test or a fixture suite.
+ *
+ * TestNamer is usually instantiated using CPPUNIT_TESTNAMER_DECL.
+ *
+ */
+class CPPUNIT_API TestNamer
+{
+public:
+#if CPPUNIT_HAVE_RTTI
+  /*! \brief Constructs a namer using the fixture's type-info.
+   * \param typeInfo Type-info of the fixture type. Use to name the fixture suite.
+   */
+  TestNamer( const std::type_info &typeInfo );
+#endif
+
+  /*! \brief Constructs a namer using the specified fixture name.
+   * \param fixtureName Name of the fixture suite. Usually extracted using a macro.
+   */
+  TestNamer( const std::string &fixtureName );
+
+  virtual ~TestNamer();
+
+  /*! \brief Returns the name of the fixture.
+   * \return Name of the fixture.
+   */
+  virtual std::string getFixtureName() const;
+
+  /*! \brief Returns the name of the test for the specified method.
+   * \param testMethodName Name of the method that implements a test.
+   * \return A string that is the concatenation of the test fixture name 
+   *         (returned by getFixtureName()) and\a testMethodName, 
+   *         separated using '::'. This provides a fairly unique name for a given
+   *         test.
+   */
+  virtual std::string getTestNameFor( const std::string &testMethodName ) const;
+
+protected:
+  std::string m_fixtureName;
+};
+
+
+CPPUNIT_NS_END
+
+#endif // CPPUNIT_EXTENSIONS_TESTNAMER_H
+
diff --git a/3rdParty/CppUnit/src/include/cppunit/extensions/TestSuiteBuilderContext.h b/3rdParty/CppUnit/src/include/cppunit/extensions/TestSuiteBuilderContext.h
new file mode 100644
index 0000000..db26926
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/extensions/TestSuiteBuilderContext.h
@@ -0,0 +1,131 @@
+#ifndef CPPUNIT_HELPER_TESTSUITEBUILDERCONTEXT_H
+#define CPPUNIT_HELPER_TESTSUITEBUILDERCONTEXT_H
+
+#include <cppunit/Portability.h>
+#include <cppunit/portability/CppUnitMap.h>
+#include <string>
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( push )
+#pragma warning( disable: 4251 )  // X needs to have dll-interface to be used by clients of class Z
+#endif
+
+
+CPPUNIT_NS_BEGIN
+
+class TestSuite;
+class TestFixture;
+class TestFixtureFactory;
+class TestNamer;
+
+/*! \brief Context used when creating test suite in HelperMacros.
+ *
+ * Base class for all context used when creating test suite. The
+ * actual context type during test suite creation is TestSuiteBuilderContext.
+ *
+ * \sa CPPUNIT_TEST_SUITE, CPPUNIT_TEST_SUITE_ADD_TEST, 
+ *     CPPUNIT_TEST_SUITE_ADD_CUSTOM_TESTS.
+ */
+class CPPUNIT_API TestSuiteBuilderContextBase
+{
+public:
+  /*! \brief Constructs a new context.
+   *
+   * You should not use this. The context is created in 
+   * CPPUNIT_TEST_SUITE().
+   */
+  TestSuiteBuilderContextBase( TestSuite &suite,
+                               const TestNamer &namer,
+                               TestFixtureFactory &factory );
+
+  virtual ~TestSuiteBuilderContextBase();
+
+  /*! \brief Adds a test to the fixture suite.
+   *
+   * \param test Test to add to the fixture suite. Must not be \c NULL.
+   */
+  void addTest( Test *test );
+
+  /*! \brief Returns the fixture name.
+   * \return Fixture name. It is the name used to name the fixture
+   *         suite.
+   */
+  std::string getFixtureName() const;
+
+  /*! \brief Returns the name of the test for the specified method.
+   *
+   * \param testMethodName Name of the method that implements a test.
+   * \return A string that is the concatenation of the test fixture name 
+   *         (returned by getFixtureName()) and\a testMethodName, 
+   *         separated using '::'. This provides a fairly unique name for a given
+   *         test.
+   */
+  std::string getTestNameFor( const std::string &testMethodName ) const;
+
+  /*! \brief Adds property pair.
+   * \param key   PropertyKey string to add.
+   * \param value PropertyValue string to add.
+   */
+  void addProperty( const std::string &key, 
+                    const std::string &value );
+  
+  /*! \brief Returns property value assigned to param key.
+   * \param key PropertyKey string.
+   */
+  const std::string getStringProperty( const std::string &key ) const;
+
+protected:
+  TestFixture *makeTestFixture() const;
+
+  // Notes: we use a vector here instead of a map to work-around the
+  // shared std::map in dll bug in VC6.
+  // See http://www.dinkumware.com/vc_fixes.html for detail.
+  typedef std::pair<std::string,std::string> Property;
+  typedef CppUnitVector<Property> Properties;
+
+  TestSuite &m_suite;
+  const TestNamer &m_namer;
+  TestFixtureFactory &m_factory;
+
+private:
+  Properties m_properties;
+};
+
+
+/*! \brief Type-sage context used when creating test suite in HelperMacros.
+ * 
+ * \sa TestSuiteBuilderContextBase.
+ */
+template<class Fixture>
+class TestSuiteBuilderContext : public TestSuiteBuilderContextBase
+{
+public:
+  typedef Fixture FixtureType;
+
+  TestSuiteBuilderContext( TestSuiteBuilderContextBase &contextBase )
+      : TestSuiteBuilderContextBase( contextBase )
+  {
+  }
+
+  /*! \brief Returns a new TestFixture instance.
+   * \return A new fixture instance. The fixture instance is returned by
+   *         the TestFixtureFactory passed on construction. The actual type 
+   *         is that of the fixture on which the static method suite() 
+   *         was called.
+   */
+  FixtureType *makeFixture() const
+  {
+    return CPPUNIT_STATIC_CAST( FixtureType *, 
+                                TestSuiteBuilderContextBase::makeTestFixture() );
+  }
+};
+
+
+CPPUNIT_NS_END
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( pop )
+#endif
+
+#endif // CPPUNIT_HELPER_TESTSUITEBUILDERCONTEXT_H
+
diff --git a/3rdParty/CppUnit/src/include/cppunit/extensions/TestSuiteFactory.h b/3rdParty/CppUnit/src/include/cppunit/extensions/TestSuiteFactory.h
new file mode 100644
index 0000000..260b483
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/extensions/TestSuiteFactory.h
@@ -0,0 +1,27 @@
+#ifndef CPPUNIT_EXTENSIONS_TESTSUITEFACTORY_H
+#define CPPUNIT_EXTENSIONS_TESTSUITEFACTORY_H
+
+#include <cppunit/extensions/TestFactory.h>
+
+CPPUNIT_NS_BEGIN
+
+
+  class Test;
+
+  /*! \brief TestFactory for TestFixture that implements a static suite() method.
+   * \see AutoRegisterSuite.
+   */
+  template<class TestCaseType>
+  class TestSuiteFactory : public TestFactory
+  {
+  public:
+    virtual Test *makeTest()
+    {
+      return TestCaseType::suite();
+    }
+  };
+
+
+CPPUNIT_NS_END
+
+#endif  // CPPUNIT_EXTENSIONS_TESTSUITEFACTORY_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/extensions/TypeInfoHelper.h b/3rdParty/CppUnit/src/include/cppunit/extensions/TypeInfoHelper.h
new file mode 100644
index 0000000..c0ecdbc
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/extensions/TypeInfoHelper.h
@@ -0,0 +1,33 @@
+#ifndef CPPUNIT_TYPEINFOHELPER_H
+#define CPPUNIT_TYPEINFOHELPER_H
+
+#include <cppunit/Portability.h>
+
+#if CPPUNIT_HAVE_RTTI
+
+#include <typeinfo>
+#include <string>
+
+CPPUNIT_NS_BEGIN
+
+
+  /**! \brief Helper to use type_info.
+   */
+  class CPPUNIT_API TypeInfoHelper
+  {
+  public:
+    /*! \brief Get the class name of the specified type_info.
+     * \param info Info which the class name is extracted from.
+     * \return The string returned by type_info::name() without
+     *         the "class" prefix. If the name is not prefixed
+     *         by "class", it is returned as this.
+     */
+    static std::string getClassName( const std::type_info &info );
+  };
+
+
+CPPUNIT_NS_END
+
+#endif  // CPPUNIT_HAVE_RTTI
+
+#endif  // CPPUNIT_TYPEINFOHELPER_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/portability/CppUnitDeque.h b/3rdParty/CppUnit/src/include/cppunit/portability/CppUnitDeque.h
new file mode 100644
index 0000000..bbab21f
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/portability/CppUnitDeque.h
@@ -0,0 +1,25 @@
+#ifndef CPPUNIT_PORTABILITY_CPPUNITDEQUE_H
+#define CPPUNIT_PORTABILITY_CPPUNITDEQUE_H
+
+// The technic used is similar to the wrapper of STLPort.
+ 
+#include <cppunit/Portability.h>
+#include <deque>
+
+
+#if CPPUNIT_STD_NEED_ALLOCATOR
+
+template<class T>
+class CppUnitDeque : public std::deque<T,CPPUNIT_STD_ALLOCATOR>
+{
+public:
+};
+
+#else // CPPUNIT_STD_NEED_ALLOCATOR
+
+#define CppUnitDeque std::deque
+
+#endif
+
+#endif // CPPUNIT_PORTABILITY_CPPUNITDEQUE_H
+
diff --git a/3rdParty/CppUnit/src/include/cppunit/portability/CppUnitMap.h b/3rdParty/CppUnit/src/include/cppunit/portability/CppUnitMap.h
new file mode 100644
index 0000000..0cdc723
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/portability/CppUnitMap.h
@@ -0,0 +1,29 @@
+#ifndef CPPUNIT_PORTABILITY_CPPUNITMAP_H
+#define CPPUNIT_PORTABILITY_CPPUNITMAP_H
+
+// The technic used is similar to the wrapper of STLPort.
+ 
+#include <cppunit/Portability.h>
+#include <functional>
+#include <map>
+
+
+#if CPPUNIT_STD_NEED_ALLOCATOR
+
+template<class Key, class T>
+class CppUnitMap : public std::map<Key
+                                  ,T
+                                  ,std::less<Key>
+                                  ,CPPUNIT_STD_ALLOCATOR>
+{
+public:
+};
+
+#else // CPPUNIT_STD_NEED_ALLOCATOR
+
+#define CppUnitMap std::map
+
+#endif
+
+#endif // CPPUNIT_PORTABILITY_CPPUNITMAP_H
+
diff --git a/3rdParty/CppUnit/src/include/cppunit/portability/CppUnitSet.h b/3rdParty/CppUnit/src/include/cppunit/portability/CppUnitSet.h
new file mode 100644
index 0000000..18b8662
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/portability/CppUnitSet.h
@@ -0,0 +1,28 @@
+#ifndef CPPUNIT_PORTABILITY_CPPUNITSET_H
+#define CPPUNIT_PORTABILITY_CPPUNITSET_H
+
+// The technic used is similar to the wrapper of STLPort.
+ 
+#include <cppunit/Portability.h>
+#include <functional>
+#include <set>
+
+
+#if CPPUNIT_STD_NEED_ALLOCATOR
+
+template<class T>
+class CppUnitSet : public std::set<T
+                                  ,std::less<T>
+                                  ,CPPUNIT_STD_ALLOCATOR>
+{
+public:
+};
+
+#else // CPPUNIT_STD_NEED_ALLOCATOR
+
+#define CppUnitSet std::set
+
+#endif
+
+#endif // CPPUNIT_PORTABILITY_CPPUNITSET_H
+
diff --git a/3rdParty/CppUnit/src/include/cppunit/portability/CppUnitVector.h b/3rdParty/CppUnit/src/include/cppunit/portability/CppUnitVector.h
new file mode 100644
index 0000000..6666a63
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/portability/CppUnitVector.h
@@ -0,0 +1,25 @@
+#ifndef CPPUNIT_PORTABILITY_CPPUNITVECTOR_H
+#define CPPUNIT_PORTABILITY_CPPUNITVECTOR_H
+
+// The technic used is similar to the wrapper of STLPort.
+ 
+#include <cppunit/Portability.h>
+#include <vector>
+
+
+#if CPPUNIT_STD_NEED_ALLOCATOR
+
+template<class T>
+class CppUnitVector : public std::vector<T,CPPUNIT_STD_ALLOCATOR>
+{
+public:
+};
+
+#else // CPPUNIT_STD_NEED_ALLOCATOR
+
+#define CppUnitVector std::vector
+
+#endif
+
+#endif // CPPUNIT_PORTABILITY_CPPUNITVECTOR_H
+
diff --git a/3rdParty/CppUnit/src/include/cppunit/portability/Stream.h b/3rdParty/CppUnit/src/include/cppunit/portability/Stream.h
new file mode 100644
index 0000000..e9beb8c
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/portability/Stream.h
@@ -0,0 +1,347 @@
+#ifndef CPPUNIT_PORTABILITY_STREAM_H_INCLUDED
+#define CPPUNIT_PORTABILITY_STREAM_H_INCLUDED
+
+// This module define:
+// Type CppUT::Stream (either std::stream or a custom type)
+// Type CppUT::OStringStream (eitjer std::ostringstream, older alternate or a custom type)
+// Functions stdCOut() & stdCErr() which returns a reference on cout & cerr stream (or our
+// custom stream).
+
+#include <cppunit/Portability.h>
+
+
+#if defined( CPPUNIT_NO_STREAM )
+
+#include <string>
+#include <stdio.h>
+#include <string.h>
+
+CPPUNIT_NS_BEGIN
+
+class StreamBuffer
+{
+public:
+   virtual ~StreamBuffer() {}
+
+   virtual void write( const char *text, unsigned int length ) = 0;
+
+   virtual void flush() {}
+};
+
+
+class StringStreamBuffer : public StreamBuffer
+{
+public:
+   std::string str() const
+   {
+      return str_;
+   }
+
+public: // overridden from StreamBuffer
+   void write( const char *text, unsigned int length )
+   {
+      str_.append( text, length );
+   }
+
+private:
+   std::string str_;
+};
+
+
+class FileStreamBuffer : public StreamBuffer
+{
+public:
+   FileStreamBuffer( FILE *file )
+      : file_( file )
+   {
+   }
+
+   FILE *file() const
+   {
+      return file_;
+   }
+
+public: // overridden from StreamBuffer
+   void write( const char *text, unsigned int length )
+   {
+      if ( file_ )
+         fwrite( text, sizeof(char), length, file_ );
+   }
+
+   void flush() 
+   {
+      if ( file_ )
+         fflush( file_ );
+   }
+
+private:
+   FILE *file_;
+};
+
+
+class OStream
+{
+public:
+   OStream()
+      : buffer_( 0 )
+   {
+   }
+
+   OStream( StreamBuffer *buffer )
+      : buffer_( buffer )
+   {
+   }
+
+   virtual ~OStream()
+   {
+     flush();
+   }
+
+   OStream &flush()
+   {
+	   if ( buffer_ )
+		    buffer_->flush();
+	   return *this;
+   }
+
+   void setBuffer( StreamBuffer *buffer )
+   {
+      buffer_ = buffer;
+   }
+
+   OStream &write( const char *text, unsigned int length )
+   {
+      if ( buffer_ )
+         buffer_->write( text, length );
+      return *this;
+   }
+
+   OStream &write( const char *text )
+   {
+      return write( text, strlen(text) );
+   }
+
+   OStream &operator <<( bool v )
+   {
+      const char *out = v ? "true" : "false";
+      return write( out );
+   }
+
+   OStream &operator <<( short v )
+   {
+      char buffer[64];
+      sprintf( buffer, "%hd", v );
+      return write( buffer );
+   }
+
+   OStream &operator <<( unsigned short v )
+   {
+      char buffer[64];
+      sprintf( buffer, "%hu", v );
+      return write( buffer );
+   }
+
+   OStream &operator <<( int v )
+   {
+      char buffer[64];
+      sprintf( buffer, "%d", v );
+      return write( buffer );
+   }
+
+   OStream &operator <<( unsigned int v )
+   {
+      char buffer[64];
+      sprintf( buffer, "%u", v );
+      return write( buffer );
+   }
+
+   OStream &operator <<( long v )
+   {
+      char buffer[64];
+      sprintf( buffer, "%ld", v );
+      return write( buffer );
+   }
+
+   OStream &operator <<( unsigned long v )
+   {
+      char buffer[64];
+      sprintf( buffer, "%lu", v );
+      return write( buffer );
+   }
+
+   OStream &operator <<( float v )
+   {
+      char buffer[128];
+      sprintf( buffer, "%.16g", double(v) );
+      return write( buffer );
+   }
+
+   OStream &operator <<( double v )
+   {
+      char buffer[128];
+      sprintf( buffer, "%.16g", v );
+      return write( buffer );
+   }
+
+   OStream &operator <<( long double v )
+   {
+      char buffer[128];
+      sprintf( buffer, "%.16g", double(v) );
+      return write( buffer );
+   }
+
+   OStream &operator <<( const void *v )
+   {
+      char buffer[64];
+      sprintf( buffer, "%p", v );
+      return write( buffer );
+   }
+
+   OStream &operator <<( const char *v )
+   {
+      return write( v ? v : "NULL" );
+   }
+
+   OStream &operator <<( char c )
+   {
+      char buffer[16];
+      sprintf( buffer, "%c", c );
+      return write( buffer );
+   }
+
+   OStream &operator <<( const std::string &s )
+   {
+      return write( s.c_str(), s.length() );
+   }
+
+private:
+   StreamBuffer *buffer_;
+};
+
+
+class OStringStream : public OStream
+{
+public:
+	OStringStream()
+		: OStream( &buffer_ )
+	{
+	}
+
+	std::string str() const
+	{
+		return buffer_.str();
+	}
+
+private:
+	StringStreamBuffer buffer_;
+};
+
+
+class OFileStream : public OStream
+{
+public:
+   OFileStream( FILE *file )
+      : OStream( &buffer_ )
+      , buffer_( file )
+      , ownFile_( false )
+   {
+   }
+
+   OFileStream( const char *path )
+      : OStream( &buffer_ )
+      , buffer_( fopen( path, "wt" ) )
+      , ownFile_( true )
+   {
+   }
+
+   virtual ~OFileStream()
+   {
+      if ( ownFile_  &&  buffer_.file() )
+         fclose( buffer_.file() );
+   }
+
+private:
+   FileStreamBuffer buffer_;
+   bool ownFile_;
+};
+
+inline OStream &stdCOut() 
+{
+   static OFileStream stream( stdout );
+   return stream;
+}
+
+inline OStream &stdCErr() 
+{
+   static OFileStream stream( stderr );
+   return stream;
+}
+
+CPPUNIT_NS_END
+
+#elif CPPUNIT_HAVE_SSTREAM // #if defined( CPPUNIT_NO_STREAM )
+# include <sstream>
+# include <fstream>
+
+    CPPUNIT_NS_BEGIN
+    typedef std::ostringstream OStringStream;      // The standard C++ way
+    typedef std::ofstream OFileStream;
+    CPPUNIT_NS_END
+
+
+#elif CPPUNIT_HAVE_CLASS_STRSTREAM
+# include <string>
+# if CPPUNIT_HAVE_STRSTREAM
+#   include <strstream>
+# else // CPPUNIT_HAVE_STRSTREAM
+#  include <strstream.h>
+# endif // CPPUNIT_HAVE_CLASS_STRSTREAM
+
+    CPPUNIT_NS_BEGIN
+
+    class OStringStream : public std::ostrstream 
+    {
+    public:
+        std::string str()
+        {
+//            (*this) << '\0';
+//            std::string msg(std::ostrstream::str());
+//            std::ostrstream::freeze(false);
+//            return msg;
+// Alternative implementation that don't rely on freeze which is not
+// available on some platforms:
+            return std::string( std::ostrstream::str(), pcount() );
+        }
+    };
+
+    CPPUNIT_NS_END
+#else // CPPUNIT_HAVE_CLASS_STRSTREAM
+#   error Cannot define CppUnit::OStringStream.
+#endif // #if defined( CPPUNIT_NO_STREAM )
+
+
+
+#if !defined( CPPUNIT_NO_STREAM )
+
+#include <iostream>
+
+    CPPUNIT_NS_BEGIN
+
+    typedef std::ostream OStream;
+
+    inline OStream &stdCOut() 
+    {
+        return std::cout;
+    }
+
+    inline OStream &stdCErr() 
+    {
+       return std::cerr;
+    }
+
+    CPPUNIT_NS_END
+   
+#endif // #if !defined( CPPUNIT_NO_STREAM )
+
+#endif // CPPUNIT_PORTABILITY_STREAM_H_INCLUDED
+
diff --git a/3rdParty/CppUnit/src/include/cppunit/tools/Algorithm.h b/3rdParty/CppUnit/src/include/cppunit/tools/Algorithm.h
new file mode 100644
index 0000000..e5746a2
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/tools/Algorithm.h
@@ -0,0 +1,23 @@
+#ifndef CPPUNIT_TOOLS_ALGORITHM_H_INCLUDED
+#define CPPUNIT_TOOLS_ALGORITHM_H_INCLUDED
+
+#include <cppunit/Portability.h>
+
+CPPUNIT_NS_BEGIN
+
+template<class SequenceType, class ValueType>
+void
+removeFromSequence( SequenceType &sequence, 
+                    const ValueType &valueToRemove )
+{
+   for ( unsigned int index =0; index < sequence.size(); ++index )
+   {
+      if ( sequence[ index ] == valueToRemove )
+         sequence.erase( sequence.begin() + index );
+   }
+}
+
+CPPUNIT_NS_END
+
+
+#endif // CPPUNIT_TOOLS_ALGORITHM_H_INCLUDED
diff --git a/3rdParty/CppUnit/src/include/cppunit/tools/StringTools.h b/3rdParty/CppUnit/src/include/cppunit/tools/StringTools.h
new file mode 100644
index 0000000..7a6b6d7
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/tools/StringTools.h
@@ -0,0 +1,34 @@
+#ifndef CPPUNIT_TOOLS_STRINGTOOLS_H
+#define CPPUNIT_TOOLS_STRINGTOOLS_H
+
+#include <cppunit/Portability.h>
+#include <string>
+#include <cppunit/portability/CppUnitVector.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+/*! \brief Tool functions to manipulate string.
+ */
+struct StringTools
+{
+
+  typedef CppUnitVector<std::string> Strings;
+
+  static std::string CPPUNIT_API toString( int value );
+
+  static std::string CPPUNIT_API toString( double value );
+
+  static Strings CPPUNIT_API split( const std::string &text, 
+                                    char separator );
+
+  static std::string CPPUNIT_API wrap( const std::string &text,
+                                       int wrapColumn = CPPUNIT_WRAP_COLUMN );
+
+};
+
+
+CPPUNIT_NS_END
+
+#endif  // CPPUNIT_TOOLS_STRINGTOOLS_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/tools/XmlDocument.h b/3rdParty/CppUnit/src/include/cppunit/tools/XmlDocument.h
new file mode 100644
index 0000000..4ee7325
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/tools/XmlDocument.h
@@ -0,0 +1,86 @@
+#ifndef CPPUNIT_TOOLS_XMLDOCUMENT_H
+#define CPPUNIT_TOOLS_XMLDOCUMENT_H
+
+#include <cppunit/Portability.h>
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( push )
+#pragma warning( disable: 4251 )  // X needs to have dll-interface to be used by clients of class Z
+#endif
+
+#include <string>
+
+
+CPPUNIT_NS_BEGIN
+
+
+class XmlElement;
+
+
+/*! \brief A XML Document.
+ *
+ * A XmlDocument represents a XML file. It holds a pointer on the root XmlElement
+ * of the document. It also holds the encoding and style sheet used.
+ *
+ * By default, the XML document is stand-alone and tagged with enconding "ISO-8859-1".
+ */
+class CPPUNIT_API XmlDocument
+{
+public:
+  /*! \brief Constructs a XmlDocument object.
+   * \param encoding Encoding used in the XML file (default is Latin-1, ISO-8859-1 ). 
+   * \param styleSheet Name of the XSL style sheet file used. If empty then no
+   *                   style sheet will be specified in the output.
+   */
+  XmlDocument( const std::string &encoding = "",
+               const std::string &styleSheet = "" );
+
+  /// Destructor.
+  virtual ~XmlDocument();
+
+  std::string encoding() const;
+  void setEncoding( const std::string &encoding = "" );
+  
+  std::string styleSheet() const;
+  void setStyleSheet( const std::string &styleSheet = "" );
+
+  bool standalone() const;
+
+  /*! \brief set the output document as standalone or not.
+   *
+   *  For the output document, specify wether it's a standalone XML
+   *  document, or not.
+   *
+   *  \param standalone if true, the output will be specified as standalone.
+   *         if false, it will be not.
+   */
+  void setStandalone( bool standalone );
+ 
+  void setRootElement( XmlElement *rootElement );
+  XmlElement &rootElement() const;
+
+  std::string toString() const;
+
+private:
+  /// Prevents the use of the copy constructor.
+  XmlDocument( const XmlDocument &copy );
+
+  /// Prevents the use of the copy operator.
+  void operator =( const XmlDocument &copy );
+
+protected:
+  std::string m_encoding;
+  std::string m_styleSheet;
+  XmlElement *m_rootElement;
+  bool m_standalone;
+};
+
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( pop )
+#endif
+
+
+CPPUNIT_NS_END
+
+#endif  // CPPUNIT_TOOLS_XMLDOCUMENT_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/tools/XmlElement.h b/3rdParty/CppUnit/src/include/cppunit/tools/XmlElement.h
new file mode 100644
index 0000000..0b36bd2
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/tools/XmlElement.h
@@ -0,0 +1,149 @@
+#ifndef CPPUNIT_TOOLS_XMLELEMENT_H
+#define CPPUNIT_TOOLS_XMLELEMENT_H
+
+#include <cppunit/Portability.h>
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( push )
+#pragma warning( disable: 4251 )  // X needs to have dll-interface to be used by clients of class Z
+#endif
+
+#include <cppunit/portability/CppUnitDeque.h>
+#include <string>
+
+
+CPPUNIT_NS_BEGIN
+
+
+class XmlElement;
+
+#if CPPUNIT_NEED_DLL_DECL
+//  template class CPPUNIT_API std::deque<XmlElement *>;
+#endif
+
+
+/*! \brief A XML Element.
+ * 
+ * A XML element has:
+ * - a name, specified on construction,
+ * - a content, specified on construction (may be empty),
+ * - zero or more attributes, added with addAttribute(),
+ * - zero or more child elements, added with addElement().
+ */
+class CPPUNIT_API XmlElement
+{
+public:
+  /*! \brief Constructs an element with the specified name and string content.
+   * \param elementName Name of the element. Must not be empty.
+   * \param content Content of the element.
+   */
+  XmlElement( std::string elementName,
+              std::string content ="" );
+
+  /*! \brief Constructs an element with the specified name and numeric content.
+   * \param elementName Name of the element. Must not be empty.
+   * \param numericContent Content of the element.
+   */
+  XmlElement( std::string elementName,
+              int numericContent );
+
+  /*! \brief Destructs the element and its child elements.
+   */
+  virtual ~XmlElement();
+
+  /*! \brief Returns the name of the element.
+   * \return Name of the element.
+   */
+  std::string name() const;
+
+  /*! \brief Returns the content of the element.
+   * \return Content of the element.
+   */
+  std::string content() const;
+
+  /*! \brief Sets the name of the element.
+   * \param name New name for the element.
+   */
+  void setName( const std::string &name );
+
+  /*! \brief Sets the content of the element.
+   * \param content New content for the element.
+   */
+  void setContent( const std::string &content );
+
+  /*! \overload void setContent( const std::string &content )
+   */
+  void setContent( int numericContent );
+
+  /*! \brief Adds an attribute with the specified string value.
+   * \param attributeName Name of the attribute. Must not be an empty.
+   * \param value Value of the attribute.
+   */
+  void addAttribute( std::string attributeName,
+                     std::string value );
+
+  /*! \brief Adds an attribute with the specified numeric value.
+   * \param attributeName Name of the attribute. Must not be empty.
+   * \param numericValue Numeric value of the attribute.
+   */
+  void addAttribute( std::string attributeName,
+                     int numericValue );
+
+  /*! \brief Adds a child element to the element.
+   * \param element Child element to add. Must not be \c NULL.
+   */
+  void addElement( XmlElement *element );
+
+  /*! \brief Returns the number of child elements.
+   * \return Number of child elements (element added with addElement()).
+   */
+  int elementCount() const;
+
+  /*! \brief Returns the child element at the specified index.
+   * \param index Zero based index of the element to return.
+   * \returns Element at the specified index. Never \c NULL.
+   * \exception std::invalid_argument if \a index < 0 or index >= elementCount().
+   */
+  XmlElement *elementAt( int index ) const;
+
+  /*! \brief Returns the first child element with the specified name.
+   * \param name Name of the child element to return.
+   * \return First child element found which is named \a name.
+   * \exception std::invalid_argument if there is no child element with the specified
+   *            name.
+   */
+  XmlElement *elementFor( const std::string &name ) const;
+
+  /*! \brief Returns a XML string that represents the element.
+   * \param indent String of spaces representing the amount of 'indent'.
+   * \return XML string that represents the element, its attributes and its
+   *         child elements.
+   */
+  std::string toString( const std::string &indent = "" ) const;
+
+private:
+  typedef std::pair<std::string,std::string> Attribute;
+
+  std::string attributesAsString() const;
+  std::string escape( std::string value ) const;
+
+private:
+  std::string m_name;
+  std::string m_content;
+
+  typedef CppUnitDeque<Attribute> Attributes;
+  Attributes m_attributes;
+
+  typedef CppUnitDeque<XmlElement *> Elements;
+  Elements m_elements;
+};
+
+
+CPPUNIT_NS_END
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( pop )
+#endif
+
+
+#endif  // CPPUNIT_TOOLS_XMLELEMENT_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/ui/text/TestRunner.h b/3rdParty/CppUnit/src/include/cppunit/ui/text/TestRunner.h
new file mode 100644
index 0000000..023eb83
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/ui/text/TestRunner.h
@@ -0,0 +1,24 @@
+#ifndef CPPUNIT_UI_TEXT_TESTRUNNER_H
+#define CPPUNIT_UI_TEXT_TESTRUNNER_H
+
+#include <cppunit/ui/text/TextTestRunner.h>
+
+
+#if defined(CPPUNIT_HAVE_NAMESPACES)
+
+CPPUNIT_NS_BEGIN
+namespace TextUi
+{
+
+  /*! Text TestRunner (DEPRECATED).
+   * \deprecated Use TextTestRunner instead.
+   */
+  typedef TextTestRunner TestRunner;
+
+}
+CPPUNIT_NS_END
+
+#endif // defined(CPPUNIT_HAVE_NAMESPACES)
+
+
+#endif  // CPPUNIT_UI_TEXT_TESTRUNNER_H
diff --git a/3rdParty/CppUnit/src/include/cppunit/ui/text/TextTestRunner.h b/3rdParty/CppUnit/src/include/cppunit/ui/text/TextTestRunner.h
new file mode 100644
index 0000000..86da4d4
--- /dev/null
+++ b/3rdParty/CppUnit/src/include/cppunit/ui/text/TextTestRunner.h
@@ -0,0 +1,97 @@
+#ifndef CPPUNIT_UI_TEXT_TEXTTESTRUNNER_H
+#define CPPUNIT_UI_TEXT_TEXTTESTRUNNER_H
+
+
+#include <cppunit/Portability.h>
+#include <string>
+#include <cppunit/TestRunner.h>
+
+CPPUNIT_NS_BEGIN
+
+
+class Outputter;
+class Test;
+class TestSuite;
+class TextOutputter;
+class TestResult;
+class TestResultCollector;
+
+
+
+/*!
+ * \brief A text mode test runner.
+ * \ingroup WritingTestResult
+ * \ingroup ExecutingTest
+ *
+ * The test runner manage the life cycle of the added tests.
+ *
+ * The test runner can run only one of the added tests or all the tests. 
+ *
+ * TestRunner prints out a trace as the tests are executed followed by a
+ * summary at the end. The trace and summary print are optional.
+ *
+ * Here is an example of use:
+ *
+ * \code
+ * CppUnit::TextTestRunner runner;
+ * runner.addTest( ExampleTestCase::suite() );
+ * runner.run( "", true );    // Run all tests and wait
+ * \endcode
+ *
+ * The trace is printed using a TextTestProgressListener. The summary is printed
+ * using a TextOutputter. 
+ *
+ * You can specify an alternate Outputter at construction
+ * or later with setOutputter(). 
+ *
+ * After construction, you can register additional TestListener to eventManager(),
+ * for a custom progress trace, for example.
+ *
+ * \code
+ * CppUnit::TextTestRunner runner;
+ * runner.addTest( ExampleTestCase::suite() );
+ * runner.setOutputter( CppUnit::CompilerOutputter::defaultOutputter( 
+ *                          &runner.result(),
+ *                          std::cerr ) );
+ * MyCustomProgressTestListener progress;
+ * runner.eventManager().addListener( &progress );
+ * runner.run( "", true );    // Run all tests and wait
+ * \endcode
+ *
+ * \see CompilerOutputter, XmlOutputter, TextOutputter.
+ */
+class CPPUNIT_API TextTestRunner : public CPPUNIT_NS::TestRunner
+{
+public:
+  TextTestRunner( Outputter *outputter =NULL );
+
+  virtual ~TextTestRunner();
+
+  bool run( std::string testPath ="",
+            bool doWait = false,
+            bool doPrintResult = true,
+            bool doPrintProgress = true );
+
+  void setOutputter( Outputter *outputter );
+
+  TestResultCollector &result() const;
+
+  TestResult &eventManager() const;
+
+public: // overridden from TestRunner (to avoid hidden virtual function warning)
+  virtual void run( TestResult &controller,
+                    const std::string &testPath = "" );
+
+protected:
+  virtual void wait( bool doWait );
+  virtual void printResult( bool doPrintResult );
+
+  TestResultCollector *m_result;
+  TestResult *m_eventManager;
+  Outputter *m_outputter;
+};
+
+
+CPPUNIT_NS_END
+
+#endif  // CPPUNIT_UI_TEXT_TEXTTESTRUNNER_H
diff --git a/3rdParty/CppUnit/src/src/cppunit/AdditionalMessage.cpp b/3rdParty/CppUnit/src/src/cppunit/AdditionalMessage.cpp
new file mode 100644
index 0000000..9f3da13
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/AdditionalMessage.cpp
@@ -0,0 +1,41 @@
+#include <cppunit/AdditionalMessage.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+AdditionalMessage::AdditionalMessage()
+{
+}
+
+
+AdditionalMessage::AdditionalMessage( const std::string &detail1 )
+{
+  if ( !detail1.empty() )
+    addDetail( detail1 );
+}
+
+
+AdditionalMessage::AdditionalMessage( const char *detail1 )
+{
+  if ( detail1  &&  !std::string( detail1 ).empty() )
+    addDetail( std::string(detail1) );
+}
+
+
+AdditionalMessage::AdditionalMessage( const Message &other )
+    : SuperClass( other )
+{
+}
+
+
+AdditionalMessage &
+AdditionalMessage::operator =( const Message &other )
+{
+  SuperClass::operator =( other );
+
+  return *this;
+}
+
+
+CPPUNIT_NS_END
diff --git a/3rdParty/CppUnit/src/src/cppunit/Asserter.cpp b/3rdParty/CppUnit/src/src/cppunit/Asserter.cpp
new file mode 100644
index 0000000..a9cf95c
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/Asserter.cpp
@@ -0,0 +1,101 @@
+#include <cppunit/Asserter.h>
+#include <cppunit/Exception.h>
+#include <cppunit/Message.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+void 
+Asserter::fail( std::string message, 
+                const SourceLine &sourceLine )
+{
+  fail( Message( "assertion failed", message ), sourceLine );
+}
+
+
+void 
+Asserter::fail( const Message &message, 
+                const SourceLine &sourceLine )
+{
+  throw Exception( message, sourceLine );
+}
+
+
+void 
+Asserter::failIf( bool shouldFail, 
+                  const Message &message, 
+                  const SourceLine &sourceLine )
+{
+  if ( shouldFail )
+    fail( message, sourceLine );
+}
+
+
+void 
+Asserter::failIf( bool shouldFail, 
+                  std::string message, 
+                  const SourceLine &sourceLine )
+{
+  failIf( shouldFail, Message( "assertion failed", message ), sourceLine );
+}
+
+
+std::string 
+Asserter::makeExpected( const std::string &expectedValue )
+{
+  return "Expected: " + expectedValue;
+}
+
+
+std::string 
+Asserter::makeActual( const std::string &actualValue )
+{
+  return "Actual  : " + actualValue;
+}
+
+
+Message 
+Asserter::makeNotEqualMessage( const std::string &expectedValue,
+                               const std::string &actualValue,
+                               const AdditionalMessage &additionalMessage,
+                               const std::string &shortDescription )
+{
+  Message message( shortDescription,
+                   makeExpected( expectedValue ),
+                   makeActual( actualValue ) );
+  message.addDetail( additionalMessage );
+
+  return message;
+}
+
+
+void 
+Asserter::failNotEqual( std::string expected, 
+                        std::string actual, 
+                        const SourceLine &sourceLine,
+                        const AdditionalMessage &additionalMessage,
+                        std::string shortDescription )
+{
+  fail( makeNotEqualMessage( expected,
+                             actual,
+                             additionalMessage,
+                             shortDescription ), 
+        sourceLine );
+}
+
+
+void 
+Asserter::failNotEqualIf( bool shouldFail,
+                          std::string expected, 
+                          std::string actual, 
+                          const SourceLine &sourceLine,
+                          const AdditionalMessage &additionalMessage,
+                          std::string shortDescription )
+{
+  if ( shouldFail )
+    failNotEqual( expected, actual, sourceLine, additionalMessage, shortDescription );
+}
+
+
+CPPUNIT_NS_END
diff --git a/3rdParty/CppUnit/src/src/cppunit/BriefTestProgressListener.cpp b/3rdParty/CppUnit/src/src/cppunit/BriefTestProgressListener.cpp
new file mode 100644
index 0000000..120e6d5
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/BriefTestProgressListener.cpp
@@ -0,0 +1,49 @@
+#include <cppunit/BriefTestProgressListener.h>
+#include <cppunit/Test.h>
+#include <cppunit/TestFailure.h>
+#include <cppunit/portability/Stream.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+BriefTestProgressListener::BriefTestProgressListener()
+    : m_lastTestFailed( false )
+{
+}
+
+
+BriefTestProgressListener::~BriefTestProgressListener()
+{
+}
+
+
+void 
+BriefTestProgressListener::startTest( Test *test )
+{
+  stdCOut() << test->getName();
+  stdCOut().flush();
+
+  m_lastTestFailed = false;
+}
+
+
+void 
+BriefTestProgressListener::addFailure( const TestFailure &failure )
+{
+  stdCOut() << " : " << (failure.isError() ? "error" : "assertion");
+  m_lastTestFailed  = true;
+}
+
+
+void 
+BriefTestProgressListener::endTest( Test *)
+{
+  if ( !m_lastTestFailed )
+    stdCOut()  <<  " : OK";
+  stdCOut() << "\n";
+}
+
+
+CPPUNIT_NS_END
+
diff --git a/3rdParty/CppUnit/src/src/cppunit/DefaultProtector.cpp b/3rdParty/CppUnit/src/src/cppunit/DefaultProtector.cpp
new file mode 100644
index 0000000..6fb306b
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/DefaultProtector.cpp
@@ -0,0 +1,42 @@
+#include <cppunit/Exception.h>
+#include <cppunit/extensions/TypeInfoHelper.h>
+#include "DefaultProtector.h"
+
+
+CPPUNIT_NS_BEGIN
+
+
+bool 
+DefaultProtector::protect( const Functor &functor,
+                           const ProtectorContext &context )
+{
+  try
+  {
+    return functor();
+  }
+  catch ( Exception &failure )
+  {
+    reportFailure( context, failure );
+  }
+  catch ( std::exception &e )
+  {
+    std::string shortDescription( "uncaught exception of type " );
+#if CPPUNIT_USE_TYPEINFO_NAME
+    shortDescription += TypeInfoHelper::getClassName( typeid(e) );
+#else
+    shortDescription += "std::exception (or derived).";
+#endif
+    Message message( shortDescription, e.what() );
+    reportError( context, message );
+  }
+  catch ( ... )
+  {
+    reportError( context,
+                 Message( "uncaught exception of unknown type") );
+  }
+  
+  return false;
+}
+
+
+CPPUNIT_NS_END
diff --git a/3rdParty/CppUnit/src/src/cppunit/DefaultProtector.h b/3rdParty/CppUnit/src/src/cppunit/DefaultProtector.h
new file mode 100644
index 0000000..4a76ea0
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/DefaultProtector.h
@@ -0,0 +1,27 @@
+#ifndef CPPUNIT_DEFAULTPROTECTOR_H
+#define CPPUNIT_DEFAULTPROTECTOR_H
+
+#include <cppunit/Protector.h>
+
+CPPUNIT_NS_BEGIN
+
+/*! \brief Default protector that catch all exceptions (Implementation).
+ *
+ * Implementation detail.
+ * \internal This protector catch and generate a failure for the following
+ * exception types:
+ * - Exception
+ * - std::exception
+ * - ...
+ */
+class DefaultProtector : public Protector
+{
+public:
+  bool protect( const Functor &functor,
+                const ProtectorContext &context );
+};
+
+CPPUNIT_NS_END
+
+#endif // CPPUNIT_DEFAULTPROTECTOR_H
+
diff --git a/3rdParty/CppUnit/src/src/cppunit/Exception.cpp b/3rdParty/CppUnit/src/src/cppunit/Exception.cpp
new file mode 100644
index 0000000..3bbe24b
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/Exception.cpp
@@ -0,0 +1,126 @@
+#include <cppunit/Exception.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+#ifdef CPPUNIT_ENABLE_SOURCELINE_DEPRECATED
+/*!
+ * \deprecated Use SourceLine::isValid() instead.
+ */
+const std::string Exception::UNKNOWNFILENAME = "<unknown>";
+
+/*!
+ * \deprecated Use SourceLine::isValid() instead.
+ */
+const long Exception::UNKNOWNLINENUMBER = -1;
+#endif
+
+
+Exception::Exception( const Exception &other )
+   : std::exception( other )
+{ 
+  m_message = other.m_message; 
+  m_sourceLine = other.m_sourceLine;
+} 
+
+
+Exception::Exception( const Message &message, 
+                      const SourceLine &sourceLine )
+    : m_message( message )
+    , m_sourceLine( sourceLine )
+{
+}
+
+
+#ifdef CPPUNIT_ENABLE_SOURCELINE_DEPRECATED
+Exception::Exception( std::string message, 
+                      long lineNumber, 
+                      std::string fileName )
+    : m_message( message )
+    , m_sourceLine( fileName, lineNumber )
+{
+}
+#endif
+
+
+Exception::~Exception() throw()
+{
+}
+
+
+Exception & 
+Exception::operator =( const Exception& other )
+{ 
+// Don't call superclass operator =(). VC++ STL implementation
+// has a bug. It calls the destructor and copy constructor of 
+// std::exception() which reset the virtual table to std::exception.
+//  SuperClass::operator =(other);
+
+  if ( &other != this )
+  {
+    m_message = other.m_message; 
+    m_sourceLine = other.m_sourceLine;
+  }
+
+  return *this; 
+}
+
+
+const char*
+Exception::what() const throw()
+{
+  Exception *mutableThis = CPPUNIT_CONST_CAST( Exception *, this );
+  mutableThis->m_whatMessage = m_message.shortDescription() + "\n" + 
+                               m_message.details();
+  return m_whatMessage.c_str();
+}
+
+
+SourceLine 
+Exception::sourceLine() const
+{
+  return m_sourceLine;
+}
+
+
+Message 
+Exception::message() const
+{
+  return m_message;
+}
+
+
+void 
+Exception::setMessage( const Message &message )
+{
+  m_message = message;
+}
+
+
+#ifdef CPPUNIT_ENABLE_SOURCELINE_DEPRECATED
+long 
+Exception::lineNumber() const
+{ 
+  return m_sourceLine.isValid() ? m_sourceLine.lineNumber() : 
+                                  UNKNOWNLINENUMBER; 
+}
+
+
+std::string 
+Exception::fileName() const
+{ 
+  return m_sourceLine.isValid() ? m_sourceLine.fileName() : 
+                                  UNKNOWNFILENAME;
+}
+#endif
+
+
+Exception *
+Exception::clone() const
+{
+  return new Exception( *this );
+}
+
+
+CPPUNIT_NS_END
diff --git a/3rdParty/CppUnit/src/src/cppunit/Message.cpp b/3rdParty/CppUnit/src/src/cppunit/Message.cpp
new file mode 100644
index 0000000..9d6a0e9
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/Message.cpp
@@ -0,0 +1,170 @@
+#include <cppunit/Message.h>
+#include <stdexcept>
+
+
+CPPUNIT_NS_BEGIN
+
+
+Message::Message()
+{
+}
+
+Message::Message( const Message &other )
+{
+   *this = other;
+}
+
+
+Message::Message( const std::string &shortDescription )
+    : m_shortDescription( shortDescription )
+{
+}
+
+
+Message::Message( const std::string &shortDescription,
+                  const std::string &detail1 )
+    : m_shortDescription( shortDescription )
+{
+  addDetail( detail1 );
+}
+
+
+Message::Message( const std::string &shortDescription,
+                  const std::string &detail1,
+                  const std::string &detail2 )
+    : m_shortDescription( shortDescription )
+{
+  addDetail( detail1, detail2 );
+}
+
+
+Message::Message( const std::string &shortDescription,
+                  const std::string &detail1,
+                  const std::string &detail2,
+                  const std::string &detail3 )
+    : m_shortDescription( shortDescription )
+{
+  addDetail( detail1, detail2, detail3 );
+}
+
+Message &
+Message::operator =( const Message &other )
+{
+   if ( this != &other )
+   {
+      m_shortDescription = other.m_shortDescription.c_str();
+      m_details.clear();
+      Details::const_iterator it = other.m_details.begin();
+      Details::const_iterator itEnd = other.m_details.end();
+      while ( it != itEnd )
+         m_details.push_back( (*it++).c_str() );
+   }
+
+   return *this;
+}
+
+
+const std::string &
+Message::shortDescription() const
+{
+  return m_shortDescription;
+}
+
+
+int 
+Message::detailCount() const
+{
+  return m_details.size();
+}
+
+
+std::string 
+Message::detailAt( int index ) const
+{
+  if ( index < 0  ||  index >= detailCount() )
+    throw std::invalid_argument( "Message::detailAt() : invalid index" );
+
+  return m_details[ index ];
+}
+
+
+std::string 
+Message::details() const
+{
+  std::string details;
+  for ( Details::const_iterator it = m_details.begin(); it != m_details.end(); ++it )
+  {
+    details += "- ";
+    details += *it;
+    details += '\n';
+  }
+  return details;
+}
+
+
+void 
+Message::clearDetails()
+{
+  m_details.clear();
+}
+
+
+void 
+Message::addDetail( const std::string &detail )
+{
+  m_details.push_back( detail );
+}
+
+
+void 
+Message::addDetail( const std::string &detail1,
+                    const std::string &detail2 )
+{
+  addDetail( detail1 );
+  addDetail( detail2 );
+}
+
+
+void 
+Message::addDetail( const std::string &detail1,
+                    const std::string &detail2,
+                    const std::string &detail3 )
+{
+  addDetail( detail1, detail2 );
+  addDetail( detail3 );
+}
+
+
+void 
+Message::addDetail( const Message &message )
+{
+  m_details.insert( m_details.end(), 
+                    message.m_details.begin(), 
+                    message.m_details.end() );
+}
+
+
+void 
+Message::setShortDescription( const std::string &shortDescription )
+{
+  m_shortDescription = shortDescription;
+}
+
+
+bool 
+Message::operator ==( const Message &other ) const
+{
+  return m_shortDescription == other.m_shortDescription  &&
+         m_details == other.m_details;
+}
+
+
+bool 
+Message::operator !=( const Message &other ) const
+{
+  return !( *this == other );
+}
+
+
+CPPUNIT_NS_END
+
diff --git a/3rdParty/CppUnit/src/src/cppunit/Protector.cpp b/3rdParty/CppUnit/src/src/cppunit/Protector.cpp
new file mode 100644
index 0000000..5c171ec
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/Protector.cpp
@@ -0,0 +1,86 @@
+#include <cppunit/Exception.h>
+#include <cppunit/Message.h>
+#include <cppunit/Protector.h>
+#include <cppunit/TestResult.h>
+#include "ProtectorContext.h"
+#include <memory>
+
+CPPUNIT_NS_BEGIN
+
+Functor::~Functor()
+{
+}
+
+
+Protector::~Protector()
+{
+}
+
+
+void 
+Protector::reportError( const ProtectorContext &context,
+                        const Exception &error ) const
+{
+  std::auto_ptr<Exception> actualError( error.clone() );
+  actualError->setMessage( actualMessage( actualError->message(), context ) );
+  context.m_result->addError( context.m_test, 
+                              actualError.release() );
+}
+
+
+
+void 
+Protector::reportError( const ProtectorContext &context,
+                        const Message &message,
+                        const SourceLine &sourceLine ) const
+{
+  reportError( context, Exception( message, sourceLine ) );
+}
+
+
+void 
+Protector::reportFailure( const ProtectorContext &context,
+                          const Exception &failure ) const
+{
+  std::auto_ptr<Exception> actualFailure( failure.clone() );
+  actualFailure->setMessage( actualMessage( actualFailure->message(), context ) );
+  context.m_result->addFailure( context.m_test, 
+                                actualFailure.release() );
+}
+
+
+Message 
+Protector::actualMessage( const Message &message,
+                          const ProtectorContext &context ) const
+{
+  Message theActualMessage;
+  if ( context.m_shortDescription.empty() )
+    theActualMessage = message;
+  else
+  {
+    theActualMessage = Message( context.m_shortDescription, 
+                                message.shortDescription() );
+    theActualMessage.addDetail( message );
+  }
+
+  return theActualMessage;
+}
+
+
+
+
+ProtectorGuard::ProtectorGuard( TestResult *result,
+                                              Protector *protector )
+    : m_result( result )
+{
+  m_result->pushProtector( protector );
+}
+
+
+ProtectorGuard::~ProtectorGuard()
+{
+  m_result->popProtector();
+}
+
+
+CPPUNIT_NS_END
diff --git a/3rdParty/CppUnit/src/src/cppunit/ProtectorChain.cpp b/3rdParty/CppUnit/src/src/cppunit/ProtectorChain.cpp
new file mode 100644
index 0000000..f528341
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/ProtectorChain.cpp
@@ -0,0 +1,86 @@
+#include "ProtectorChain.h"
+
+CPPUNIT_NS_BEGIN
+
+
+class ProtectorChain::ProtectFunctor : public Functor
+{
+public:
+  ProtectFunctor( Protector *protector,
+                  const Functor &functor,
+                  const ProtectorContext &context )
+      : m_protector( protector )
+      , m_functor( functor )
+      , m_context( context )
+  {
+  }
+
+  bool operator()() const
+  {
+    return m_protector->protect( m_functor, m_context );
+  }
+
+private:
+  Protector *m_protector;
+  const Functor &m_functor;
+  const ProtectorContext &m_context;
+};
+
+
+ProtectorChain::~ProtectorChain()
+{
+  while ( count() > 0 )
+    pop();
+}
+
+
+void 
+ProtectorChain::push( Protector *protector )
+{
+  m_protectors.push_back( protector );
+}
+
+
+void 
+ProtectorChain::pop()
+{
+  delete m_protectors.back();
+  m_protectors.pop_back();
+}
+
+int 
+ProtectorChain::count() const
+{
+  return m_protectors.size();
+}
+
+
+bool 
+ProtectorChain::protect( const Functor &functor,
+                         const ProtectorContext &context )
+{
+  if ( m_protectors.empty() )
+    return functor();
+
+  Functors functors;
+  for ( int index = m_protectors.size()-1; index >= 0; --index )
+  {
+    const Functor &protectedFunctor = 
+              functors.empty() ? functor : *functors.back();
+
+    functors.push_back( new ProtectFunctor( m_protectors[index],
+                                            protectedFunctor, 
+                                            context ) );
+  }
+
+  const Functor &outermostFunctor = *functors.back();
+  bool succeed = outermostFunctor();
+
+  for ( unsigned int deletingIndex = 0; deletingIndex < m_protectors.size(); ++deletingIndex )
+    delete functors[deletingIndex];
+
+  return succeed;
+}
+
+
+CPPUNIT_NS_END
diff --git a/3rdParty/CppUnit/src/src/cppunit/ProtectorChain.h b/3rdParty/CppUnit/src/src/cppunit/ProtectorChain.h
new file mode 100644
index 0000000..711b56f
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/ProtectorChain.h
@@ -0,0 +1,51 @@
+#ifndef CPPUNIT_PROTECTORCHAIN_H
+#define CPPUNIT_PROTECTORCHAIN_H
+
+#include <cppunit/Protector.h>
+#include <cppunit/portability/CppUnitDeque.h>
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( push )
+#pragma warning( disable: 4251 )  // X needs to have dll-interface to be used by clients of class Z
+#endif
+
+
+CPPUNIT_NS_BEGIN
+
+/*! \brief Protector chain (Implementation).
+ * Implementation detail.
+ * \internal Protector that protect a Functor using a chain of nested Protector.
+ */
+class CPPUNIT_API ProtectorChain : public Protector
+{
+public:
+  ~ProtectorChain();
+
+  void push( Protector *protector );
+
+  void pop();
+
+  int count() const;
+
+  bool protect( const Functor &functor,
+                const ProtectorContext &context );
+
+private:
+  class ProtectFunctor;
+
+private:
+  typedef CppUnitDeque<Protector *> Protectors;
+  Protectors m_protectors;
+
+  typedef CppUnitDeque<Functor *> Functors;
+};
+
+
+CPPUNIT_NS_END
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( pop )
+#endif
+
+#endif // CPPUNIT_PROTECTORCHAIN_H
+
diff --git a/3rdParty/CppUnit/src/src/cppunit/ProtectorContext.h b/3rdParty/CppUnit/src/src/cppunit/ProtectorContext.h
new file mode 100644
index 0000000..c3d496c
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/ProtectorContext.h
@@ -0,0 +1,38 @@
+#ifndef CPPUNIT_PROTECTORCONTEXT_H
+#define CPPUNIT_PROTECTORCONTEXT_H
+
+#include <cppunit/Portability.h>
+#include <string>
+
+CPPUNIT_NS_BEGIN
+
+class Test;
+class TestResult;
+
+
+/*! \brief Protector context (Implementation).
+ * Implementation detail.
+ * \internal Context use to report failure in Protector.
+ */
+class CPPUNIT_API ProtectorContext
+{
+public:
+  ProtectorContext( Test *test,
+                    TestResult *result,
+                    const std::string &shortDescription )
+      : m_test( test )
+      , m_result( result )
+      , m_shortDescription( shortDescription )
+  {
+  }
+
+  Test *m_test;
+  TestResult *m_result;
+  std::string m_shortDescription;
+};
+
+
+CPPUNIT_NS_END
+
+#endif // CPPUNIT_PROTECTORCONTEXT_H
+
diff --git a/3rdParty/CppUnit/src/src/cppunit/SourceLine.cpp b/3rdParty/CppUnit/src/src/cppunit/SourceLine.cpp
new file mode 100644
index 0000000..dfadae3
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/SourceLine.cpp
@@ -0,0 +1,81 @@
+#include <cppunit/SourceLine.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+SourceLine::SourceLine() :
+    m_lineNumber( -1 )
+{
+}
+
+
+SourceLine::SourceLine( const SourceLine &other )
+   : m_fileName( other.m_fileName.c_str() )
+   , m_lineNumber( other.m_lineNumber )
+{
+}
+
+
+SourceLine::SourceLine( const std::string &fileName,
+                        int lineNumber )
+   : m_fileName( fileName.c_str() )
+   , m_lineNumber( lineNumber )
+{
+}
+
+
+SourceLine &
+SourceLine::operator =( const SourceLine &other )
+{
+   if ( this != &other )
+   {
+      m_fileName = other.m_fileName.c_str();
+      m_lineNumber = other.m_lineNumber;
+   }
+   return *this;
+}
+
+
+SourceLine::~SourceLine()
+{
+}
+
+
+bool 
+SourceLine::isValid() const
+{
+  return !m_fileName.empty();
+}
+
+
+int 
+SourceLine::lineNumber() const
+{
+  return m_lineNumber;
+}
+
+
+std::string 
+SourceLine::fileName() const
+{
+  return m_fileName;
+}
+
+
+bool 
+SourceLine::operator ==( const SourceLine &other ) const
+{
+  return m_fileName == other.m_fileName  &&
+         m_lineNumber == other.m_lineNumber;
+}
+
+
+bool 
+SourceLine::operator !=( const SourceLine &other ) const
+{
+  return !( *this == other );
+}
+
+
+CPPUNIT_NS_END
diff --git a/3rdParty/CppUnit/src/src/cppunit/StringTools.cpp b/3rdParty/CppUnit/src/src/cppunit/StringTools.cpp
new file mode 100644
index 0000000..dc995d8
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/StringTools.cpp
@@ -0,0 +1,80 @@
+#include <cppunit/tools/StringTools.h>
+#include <cppunit/portability/Stream.h>
+#include <algorithm>
+
+
+CPPUNIT_NS_BEGIN
+
+
+std::string 
+StringTools::toString( int value )
+{
+  OStringStream stream;
+  stream << value;
+  return stream.str();
+}
+
+
+std::string 
+StringTools::toString( double value )
+{
+  OStringStream stream;
+  stream << value;
+  return stream.str();
+}
+
+
+StringTools::Strings
+StringTools::split( const std::string &text, 
+                    char separator )
+{
+  Strings splittedText;
+
+  std::string::const_iterator itStart = text.begin();
+  while ( !text.empty() )
+  {
+    std::string::const_iterator itSeparator = std::find( itStart, 
+                                                         text.end(), 
+                                                         separator );
+    splittedText.push_back( text.substr( itStart - text.begin(),
+                                         itSeparator - itStart ) );
+    if ( itSeparator == text.end() )
+      break;
+    itStart = itSeparator +1;
+  }
+
+  return splittedText;
+}
+
+
+std::string 
+StringTools::wrap( const std::string &text,
+                   int wrapColumn )
+{
+  const char lineBreak = '\n';
+  Strings lines = split( text, lineBreak );
+
+  std::string wrapped;
+  for ( Strings::const_iterator it = lines.begin(); it != lines.end(); ++it )
+  {
+    if ( it != lines.begin() )
+      wrapped += lineBreak;
+
+    const std::string &line = *it;
+    unsigned int index =0;
+    while ( index < line.length() )
+    {
+      std::string lineSlice( line.substr( index, wrapColumn ) );
+      wrapped += lineSlice;
+      index += wrapColumn;
+      if ( index < line.length() )
+        wrapped += lineBreak;
+    }
+  }
+
+  return wrapped;
+}
+
+
+CPPUNIT_NS_END
+
diff --git a/3rdParty/CppUnit/src/src/cppunit/SynchronizedObject.cpp b/3rdParty/CppUnit/src/src/cppunit/SynchronizedObject.cpp
new file mode 100644
index 0000000..1764538
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/SynchronizedObject.cpp
@@ -0,0 +1,32 @@
+#include <cppunit/SynchronizedObject.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+SynchronizedObject::SynchronizedObject( SynchronizationObject *syncObject )
+    : m_syncObject( syncObject == 0 ? new SynchronizationObject() : 
+                                      syncObject )
+{
+}
+
+
+SynchronizedObject::~SynchronizedObject()
+{
+  delete m_syncObject;
+}
+
+
+/** Accept a new synchronization object for protection of this instance
+ * TestResult assumes ownership of the object
+ */
+void 
+SynchronizedObject::setSynchronizationObject( SynchronizationObject *syncObject )
+{ 
+  delete m_syncObject; 
+  m_syncObject = syncObject; 
+}
+
+
+CPPUNIT_NS_END
+
diff --git a/3rdParty/CppUnit/src/src/cppunit/Test.cpp b/3rdParty/CppUnit/src/src/cppunit/Test.cpp
new file mode 100644
index 0000000..fef8be7
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/Test.cpp
@@ -0,0 +1,97 @@
+#include <cppunit/Portability.h>
+#include <cppunit/Test.h>
+#include <cppunit/TestPath.h>
+#include <stdexcept>
+
+
+CPPUNIT_NS_BEGIN
+
+
+Test *
+Test::getChildTestAt( int index ) const
+{
+  checkIsValidIndex( index );
+  return doGetChildTestAt( index );
+}
+
+
+Test *
+Test::findTest( const std::string &testName ) const
+{
+  TestPath path;
+  Test *mutableThis = CPPUNIT_CONST_CAST( Test *, this );
+  mutableThis->findTestPath( testName, path );
+  if ( !path.isValid() )
+    throw std::invalid_argument( "No test named <" + testName + "> found in test <"
+                                 + getName() + ">." );
+  return path.getChildTest();
+}
+
+
+bool 
+Test::findTestPath( const std::string &testName,
+                    TestPath &testPath ) const
+{
+  Test *mutableThis = CPPUNIT_CONST_CAST( Test *, this );
+  if ( getName() == testName )
+  {
+    testPath.add( mutableThis );
+    return true;
+  }
+
+  int childCount = getChildTestCount();
+  for ( int childIndex =0; childIndex < childCount; ++childIndex )
+  {
+    if ( getChildTestAt( childIndex )->findTestPath( testName, testPath ) )
+    {
+      testPath.insert( mutableThis, 0 );
+      return true;
+    }
+  }
+
+  return false;
+}
+
+
+bool 
+Test::findTestPath( const Test *test,
+                    TestPath &testPath ) const
+{
+  Test *mutableThis = CPPUNIT_CONST_CAST( Test *, this );
+  if ( this == test )
+  {
+    testPath.add( mutableThis );
+    return true;
+  }
+
+  int childCount = getChildTestCount();
+  for ( int childIndex =0; childIndex < childCount; ++childIndex )
+  {
+    if ( getChildTestAt( childIndex )->findTestPath( test, testPath ) )
+    {
+      testPath.insert( mutableThis, 0 );
+      return true;
+    }
+  }
+
+  return false;
+}
+
+
+TestPath 
+Test::resolveTestPath( const std::string &testPath ) const
+{
+  Test *mutableThis = CPPUNIT_CONST_CAST( Test *, this );
+  return TestPath( mutableThis, testPath );
+}
+
+
+void 
+Test::checkIsValidIndex( int index ) const
+{
+  if ( index < 0  ||  index >= getChildTestCount() )
+    throw std::out_of_range( "Test::checkValidIndex(): invalid index" );
+}
+  
+
+CPPUNIT_NS_END
diff --git a/3rdParty/CppUnit/src/src/cppunit/TestCase.cpp b/3rdParty/CppUnit/src/src/cppunit/TestCase.cpp
new file mode 100644
index 0000000..13c0525
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/TestCase.cpp
@@ -0,0 +1,137 @@
+#include <cppunit/Portability.h>
+#include <cppunit/Exception.h>
+#include <cppunit/Protector.h>
+#include <cppunit/TestCase.h>
+#include <cppunit/TestResult.h>
+#include <stdexcept>
+
+#if CPPUNIT_USE_TYPEINFO_NAME
+#  include <typeinfo>
+#endif
+
+CPPUNIT_NS_BEGIN
+
+/*! \brief Functor to call test case method (Implementation).
+ *
+ * Implementation detail.
+ */
+class TestCaseMethodFunctor : public Functor
+{
+public:
+  typedef void (TestCase::*Method)();
+
+  TestCaseMethodFunctor( TestCase *target,
+                         Method method )
+     : m_target( target )
+     , m_method( method )
+  {
+  }
+
+  bool operator()() const
+  {
+    (m_target->*m_method)();
+    return true;
+  }
+
+private:
+  TestCase *m_target;
+  Method m_method;
+};
+
+
+/** Constructs a test case.
+ *  \param name the name of the TestCase.
+ **/
+TestCase::TestCase( const std::string &name )
+    : m_name(name)
+{
+}
+
+
+/// Run the test and catch any exceptions that are triggered by it 
+void 
+TestCase::run( TestResult *result )
+{
+  result->startTest(this);
+/*
+  try {
+    setUp();
+
+    try {
+      runTest();
+    }
+    catch ( Exception &e ) {
+      Exception *copy = e.clone();
+      result->addFailure( this, copy );
+    }
+    catch ( std::exception &e ) {
+      result->addError( this, new Exception( Message( "uncaught std::exception", 
+                                                      e.what() ) ) );
+    }
+    catch (...) {
+      Exception *e = new Exception( Message( "uncaught unknown exception" ) );
+      result->addError( this, e );
+    }
+
+    try {
+      tearDown();
+    }
+    catch (...) {
+      result->addError( this, new Exception( Message( "tearDown() failed" ) ) );
+    }
+  }
+  catch (...) {
+    result->addError( this, new Exception( Message( "setUp() failed" ) ) );
+  }
+*/
+  if ( result->protect( TestCaseMethodFunctor( this, &TestCase::setUp ),
+                        this,
+                       "setUp() failed" ) )
+  {
+    result->protect( TestCaseMethodFunctor( this, &TestCase::runTest ),
+                     this );
+  }
+
+  result->protect( TestCaseMethodFunctor( this, &TestCase::tearDown ),
+                   this,
+                   "tearDown() failed" );
+
+  result->endTest( this );
+}
+
+
+/// All the work for runTest is deferred to subclasses 
+void 
+TestCase::runTest()
+{
+}
+
+
+/** Constructs a test case for a suite.
+ * \deprecated This constructor was used by fixture when TestFixture did not exist.
+ *             Have your fixture inherits TestFixture instead of TestCase.
+ * \internal
+ *  This TestCase was intended for use by the TestCaller and should not
+ *  be used by a test case for which run() is called.
+ **/
+TestCase::TestCase()
+    : m_name( "" )
+{
+}
+
+
+/// Destructs a test case
+TestCase::~TestCase()
+{
+}
+
+
+/// Returns the name of the test case
+std::string 
+TestCase::getName() const
+{ 
+  return m_name; 
+}
+  
+
+CPPUNIT_NS_END
diff --git a/3rdParty/CppUnit/src/src/cppunit/TestComposite.cpp b/3rdParty/CppUnit/src/src/cppunit/TestComposite.cpp
new file mode 100644
index 0000000..4768791
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/TestComposite.cpp
@@ -0,0 +1,77 @@
+#include <cppunit/TestComposite.h>
+#include <cppunit/TestResult.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+TestComposite::TestComposite( const std::string &name )
+    : m_name( name )
+{
+}
+
+
+TestComposite::~TestComposite()
+{
+}
+
+
+void 
+TestComposite::run( TestResult *result )
+{
+  doStartSuite( result );
+  doRunChildTests( result );
+  doEndSuite( result );
+}
+
+
+int 
+TestComposite::countTestCases() const
+{
+  int count = 0;
+  
+  int childCount = getChildTestCount();
+  for ( int index =0; index < childCount; ++index )
+    count += getChildTestAt( index )->countTestCases();
+  
+  return count;
+}
+
+
+std::string 
+TestComposite::getName() const
+{
+  return m_name;
+}
+
+
+void 
+TestComposite::doStartSuite( TestResult *controller )
+{
+  controller->startSuite( this );
+}
+
+
+void 
+TestComposite::doRunChildTests( TestResult *controller )
+{
+  int childCount = getChildTestCount();
+  for ( int index =0; index < childCount; ++index )
+  {
+    if ( controller->shouldStop() )
+      break;
+
+    getChildTestAt( index )->run( controller );
+  }
+}
+
+
+void 
+TestComposite::doEndSuite( TestResult *controller )
+{
+  controller->endSuite( this );
+}
+
+
+CPPUNIT_NS_END
+
diff --git a/3rdParty/CppUnit/src/src/cppunit/TestFactoryRegistry.cpp b/3rdParty/CppUnit/src/src/cppunit/TestFactoryRegistry.cpp
new file mode 100644
index 0000000..3457da3
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/TestFactoryRegistry.cpp
@@ -0,0 +1,161 @@
+#include <cppunit/config/SourcePrefix.h>
+#include <cppunit/extensions/TestFactoryRegistry.h>
+#include <cppunit/portability/CppUnitMap.h>
+#include <cppunit/TestSuite.h>
+#include <assert.h>
+
+
+CPPUNIT_NS_BEGIN
+
+/*! \brief (INTERNAL) List of all TestFactoryRegistry.
+ */
+class TestFactoryRegistryList
+{
+private:
+  typedef CppUnitMap<std::string, TestFactoryRegistry *, std::less<std::string> > Registries;
+  Registries m_registries;
+
+  enum State {
+    doNotChange =0,
+    notCreated,
+    exist,
+    destroyed
+  };
+
+  static State stateFlag( State newState = doNotChange )
+  {
+    static State state = notCreated;
+    if ( newState != doNotChange )
+      state = newState;
+    return state;
+  }
+
+  static TestFactoryRegistryList *getInstance()
+  {
+    static TestFactoryRegistryList list;
+    return &list;
+  }
+
+  TestFactoryRegistry *getInternalRegistry( const std::string &name )
+  {
+    Registries::const_iterator foundIt = m_registries.find( name );
+    if ( foundIt == m_registries.end() )
+    {
+      TestFactoryRegistry *factory = new TestFactoryRegistry( name );
+      m_registries.insert( std::pair<const std::string, TestFactoryRegistry*>( name, factory ) );
+      return factory;
+    }
+    return (*foundIt).second;
+  }
+
+public:
+  TestFactoryRegistryList()
+  {
+    stateFlag( exist );
+  }
+
+  ~TestFactoryRegistryList()
+  {
+    for ( Registries::iterator it = m_registries.begin(); it != m_registries.end(); ++it )
+      delete (*it).second;
+
+    stateFlag( destroyed );
+  }
+
+  static TestFactoryRegistry *getRegistry( const std::string &name )
+  {
+    // If the following assertion failed, then TestFactoryRegistry::getRegistry() 
+    // was called during static variable destruction without checking the registry 
+    // validity beforehand using TestFactoryRegistry::isValid() beforehand.
+    assert( isValid() );
+    if ( !isValid() )         // release mode
+      return NULL;            // => force CRASH
+
+    return getInstance()->getInternalRegistry( name );
+  }
+
+  static bool isValid()
+  {
+    return stateFlag() != destroyed;
+  }
+};
+
+
+
+TestFactoryRegistry::TestFactoryRegistry( std::string name ) :
+    m_name( name )
+{
+}
+
+
+TestFactoryRegistry::~TestFactoryRegistry()
+{
+}
+
+
+TestFactoryRegistry &
+TestFactoryRegistry::getRegistry( const std::string &name )
+{
+  return *TestFactoryRegistryList::getRegistry( name );
+}
+
+
+void 
+TestFactoryRegistry::registerFactory( const std::string &,
+                                      TestFactory *factory )
+{
+  registerFactory( factory );
+}
+
+
+void 
+TestFactoryRegistry::registerFactory( TestFactory *factory )
+{
+  m_factories.insert( factory );
+}
+
+
+void 
+TestFactoryRegistry::unregisterFactory( TestFactory *factory )
+{
+  m_factories.erase( factory );
+}
+
+
+void 
+TestFactoryRegistry::addRegistry( const std::string &name )
+{
+  registerFactory( &getRegistry( name ) );
+}
+
+
+Test *
+TestFactoryRegistry::makeTest()
+{
+  TestSuite *suite = new TestSuite( m_name );
+  addTestToSuite( suite );
+  return suite;
+}
+
+
+void 
+TestFactoryRegistry::addTestToSuite( TestSuite *suite )
+{
+  for ( Factories::iterator it = m_factories.begin(); 
+        it != m_factories.end(); 
+        ++it )
+  {
+    TestFactory *factory = *it;
+    suite->addTest( factory->makeTest() );
+  }
+}
+
+
+bool 
+TestFactoryRegistry::isValid()
+{
+  return TestFactoryRegistryList::isValid();
+}
+
+
+CPPUNIT_NS_END
diff --git a/3rdParty/CppUnit/src/src/cppunit/TestFailure.cpp b/3rdParty/CppUnit/src/src/cppunit/TestFailure.cpp
new file mode 100644
index 0000000..e31e138
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/TestFailure.cpp
@@ -0,0 +1,71 @@
+#include <cppunit/Exception.h>
+#include <cppunit/Test.h>
+#include <cppunit/TestFailure.h>
+
+CPPUNIT_NS_BEGIN
+
+
+/// Constructs a TestFailure with the given test and exception.
+TestFailure::TestFailure( Test *failedTest, 
+                          Exception *thrownException,
+                          bool isError ) :
+    m_failedTest( failedTest ), 
+    m_thrownException( thrownException ),
+    m_isError( isError )
+{
+}
+
+/// Deletes the owned exception.
+TestFailure::~TestFailure()
+{ 
+  delete m_thrownException; 
+}
+
+/// Gets the failed test.
+Test *
+TestFailure::failedTest() const
+{ 
+  return m_failedTest; 
+}
+
+
+/// Gets the thrown exception. Never \c NULL.
+Exception *
+TestFailure::thrownException() const
+{ 
+  return m_thrownException; 
+}
+
+
+/// Gets the failure location.
+SourceLine 
+TestFailure::sourceLine() const
+{
+  return m_thrownException->sourceLine();
+}
+
+
+/// Indicates if the failure is a failed assertion or an error.
+bool 
+TestFailure::isError() const
+{
+  return m_isError;
+}
+
+
+/// Gets the name of the failed test.
+std::string 
+TestFailure::failedTestName() const
+{
+  return m_failedTest->getName();
+}
+
+
+TestFailure *
+TestFailure::clone() const
+{
+  return new TestFailure( m_failedTest, m_thrownException->clone(), m_isError );
+}
+
+
+CPPUNIT_NS_END
diff --git a/3rdParty/CppUnit/src/src/cppunit/TestLeaf.cpp b/3rdParty/CppUnit/src/src/cppunit/TestLeaf.cpp
new file mode 100644
index 0000000..3d8767c
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/TestLeaf.cpp
@@ -0,0 +1,28 @@
+#include <cppunit/TestLeaf.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+int 
+TestLeaf::countTestCases() const
+{
+  return 1;
+}
+
+
+int 
+TestLeaf::getChildTestCount() const
+{
+  return 0;
+}
+
+
+Test *
+TestLeaf::doGetChildTestAt( int index ) const
+{
+  checkIsValidIndex( index );
+  return NULL;    // never called, checkIsValidIndex() always throw.
+}
+
+CPPUNIT_NS_END
diff --git a/3rdParty/CppUnit/src/src/cppunit/TestNamer.cpp b/3rdParty/CppUnit/src/src/cppunit/TestNamer.cpp
new file mode 100644
index 0000000..eec9be9
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/TestNamer.cpp
@@ -0,0 +1,44 @@
+#include <cppunit/extensions/TestNamer.h>
+#include <cppunit/extensions/TypeInfoHelper.h>
+#include <string>
+
+
+CPPUNIT_NS_BEGIN
+
+
+#if CPPUNIT_HAVE_RTTI
+TestNamer::TestNamer( const std::type_info &typeInfo )
+{
+  m_fixtureName = TypeInfoHelper::getClassName( typeInfo );
+}
+#endif
+
+
+TestNamer::TestNamer( const std::string &fixtureName )
+  : m_fixtureName( fixtureName )
+{
+}
+
+
+TestNamer::~TestNamer()
+{
+}
+
+
+std::string 
+TestNamer::getFixtureName() const
+{
+  return m_fixtureName;
+}
+
+
+std::string 
+TestNamer::getTestNameFor( const std::string &testMethodName ) const
+{
+  return getFixtureName() + "::" + testMethodName;
+}
+
+
+
+
+CPPUNIT_NS_END
diff --git a/3rdParty/CppUnit/src/src/cppunit/TestPath.cpp b/3rdParty/CppUnit/src/src/cppunit/TestPath.cpp
new file mode 100644
index 0000000..a2783a2
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/TestPath.cpp
@@ -0,0 +1,254 @@
+#include <cppunit/Portability.h>
+#include <cppunit/Test.h>
+#include <cppunit/TestPath.h>
+#include <stdexcept>
+
+
+CPPUNIT_NS_BEGIN
+
+
+TestPath::TestPath()
+{
+}
+
+
+TestPath::TestPath( Test *root )
+{
+  add( root );
+}
+
+
+TestPath::TestPath( const TestPath &other, 
+                    int indexFirst, 
+                    int count )
+{
+  int countAdjustment = 0;
+  if ( indexFirst < 0 )
+  {
+    countAdjustment = indexFirst;
+    indexFirst = 0;
+  }
+
+  if ( count < 0 )
+    count = other.getTestCount();
+  else
+    count += countAdjustment;
+
+  int index = indexFirst;
+  while ( count-- > 0  &&  index < other.getTestCount() )
+    add( other.getTestAt( index++ ) );
+}
+
+
+TestPath::TestPath( Test *searchRoot, 
+                    const std::string &pathAsString )
+{
+  PathTestNames testNames;
+
+  Test *parentTest = findActualRoot( searchRoot, pathAsString, testNames );
+  add( parentTest );
+
+  for ( unsigned int index = 1; index < testNames.size(); ++index )
+  {
+    bool childFound = false;
+    for ( int childIndex =0; childIndex < parentTest->getChildTestCount(); ++childIndex )
+    {
+      if ( parentTest->getChildTestAt( childIndex )->getName() == testNames[index] )
+      {
+        childFound = true;
+        parentTest = parentTest->getChildTestAt( childIndex );
+        break;
+      }
+    }
+
+    if ( !childFound )
+      throw std::invalid_argument( "TestPath::TestPath(): failed to resolve test name <"+
+                                   testNames[index] + "> of path <" + pathAsString + ">" );
+
+    add( parentTest );
+  }
+}
+
+
+TestPath::TestPath( const TestPath &other )
+  : m_tests( other.m_tests )
+{
+}
+
+
+TestPath::~TestPath()
+{
+}
+
+
+TestPath &
+TestPath::operator =( const TestPath &other )
+{
+  if ( &other != this )
+    m_tests = other.m_tests;
+  return *this;
+}
+
+
+bool 
+TestPath::isValid() const
+{
+  return getTestCount() > 0;
+}
+
+
+void 
+TestPath::add( Test *test )
+{
+  m_tests.push_back( test );
+}
+
+
+void 
+TestPath::add( const TestPath &path )
+{
+  for ( int index =0; index < path.getTestCount(); ++index )
+    add( path.getTestAt( index ) );
+}
+
+
+void 
+TestPath::insert( Test *test, 
+                  int index )
+{
+  if ( index < 0  ||  index > getTestCount() )
+    throw std::out_of_range( "TestPath::insert(): index out of range" );
+  m_tests.insert( m_tests.begin() + index, test );
+}
+
+void 
+TestPath::insert( const TestPath &path, 
+                  int index )
+{
+  int itemIndex = path.getTestCount() -1;
+  while ( itemIndex >= 0 )
+    insert( path.getTestAt( itemIndex-- ), index );
+}
+
+
+void 
+TestPath::removeTests()
+{
+  while ( isValid() )
+    removeTest( 0 );
+}
+
+
+void 
+TestPath::removeTest( int index )
+{
+  checkIndexValid( index );
+  m_tests.erase( m_tests.begin() + index );
+}
+
+
+void 
+TestPath::up()
+{
+  checkIndexValid( 0 );
+  removeTest( getTestCount() -1 );
+}
+
+
+int 
+TestPath::getTestCount() const
+{
+  return m_tests.size();
+}
+
+
+Test *
+TestPath::getTestAt( int index ) const
+{
+  checkIndexValid( index );
+  return m_tests[index];
+}
+
+
+Test *
+TestPath::getChildTest() const
+{
+  return getTestAt( getTestCount() -1 );
+}
+
+
+void 
+TestPath::checkIndexValid( int index ) const
+{
+  if ( index < 0  ||  index >= getTestCount() )
+    throw std::out_of_range( "TestPath::checkIndexValid(): index out of range" );
+}
+
+
+std::string 
+TestPath::toString() const
+{
+  std::string asString( "/" );
+  for ( int index =0; index < getTestCount(); ++index )
+  {
+    if ( index > 0 )
+      asString += '/';
+    asString += getTestAt(index)->getName();
+  }
+
+  return asString;
+}
+
+
+Test *
+TestPath::findActualRoot( Test *searchRoot,
+                          const std::string &pathAsString,
+                          PathTestNames &testNames )
+{
+  bool isRelative = splitPathString( pathAsString, testNames );
+
+  if ( isRelative  &&  pathAsString.empty() )
+    return searchRoot;
+
+  if ( testNames.empty() )
+    throw std::invalid_argument( "TestPath::TestPath(): invalid root or root name in absolute path" );
+
+  Test *root = isRelative ? searchRoot->findTest( testNames[0] )  // throw if bad test name
+                          : searchRoot;
+  if ( root->getName() != testNames[0] )
+    throw std::invalid_argument( "TestPath::TestPath(): searchRoot does not match path root name" );
+
+  return root;
+}
+
+
+bool
+TestPath::splitPathString( const std::string &pathAsString,
+                           PathTestNames &testNames )
+{
+  if ( pathAsString.empty() )
+    return true;
+
+  bool isRelative = pathAsString[0] != '/';
+
+  int index = (isRelative ? 0 : 1);
+  while ( true )
+  {
+    int separatorIndex = pathAsString.find( '/', index );
+    if ( separatorIndex >= 0 )
+    {
+      testNames.push_back( pathAsString.substr( index, separatorIndex - index ) );
+      index = separatorIndex + 1;
+    }
+    else
+    {
+      testNames.push_back( pathAsString.substr( index ) );
+      break;
+    }
+  }
+
+  return isRelative;
+}
+  
+
+CPPUNIT_NS_END
diff --git a/3rdParty/CppUnit/src/src/cppunit/TestResult.cpp b/3rdParty/CppUnit/src/src/cppunit/TestResult.cpp
new file mode 100644
index 0000000..6be19f1
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/TestResult.cpp
@@ -0,0 +1,196 @@
+#include <cppunit/Test.h>
+#include <cppunit/TestFailure.h>
+#include <cppunit/TestListener.h>
+#include <cppunit/TestResult.h>
+#include <cppunit/tools/Algorithm.h>
+#include <algorithm>
+#include "DefaultProtector.h"
+#include "ProtectorChain.h"
+#include "ProtectorContext.h"
+
+CPPUNIT_NS_BEGIN
+
+
+TestResult::TestResult( SynchronizationObject *syncObject )
+    : SynchronizedObject( syncObject )
+    , m_protectorChain( new ProtectorChain() )
+    , m_stop( false )
+{ 
+  m_protectorChain->push( new DefaultProtector() );
+}
+
+
+TestResult::~TestResult()
+{
+  delete m_protectorChain;
+}
+
+
+void 
+TestResult::reset()
+{
+  ExclusiveZone zone( m_syncObject ); 
+  m_stop = false;
+}
+
+
+void 
+TestResult::addError( Test *test, 
+                      Exception *e )
+{ 
+  TestFailure failure( test, e, true );
+  addFailure( failure );
+}
+
+
+void 
+TestResult::addFailure( Test *test, Exception *e )
+{ 
+  TestFailure failure( test, e, false );
+  addFailure( failure );
+}
+
+
+void 
+TestResult::addFailure( const TestFailure &failure )
+{
+  ExclusiveZone zone( m_syncObject ); 
+  for ( TestListeners::iterator it = m_listeners.begin();
+        it != m_listeners.end(); 
+        ++it )
+    (*it)->addFailure( failure );
+}
+
+
+void 
+TestResult::startTest( Test *test )
+{ 
+  ExclusiveZone zone( m_syncObject ); 
+  for ( TestListeners::iterator it = m_listeners.begin();
+        it != m_listeners.end(); 
+        ++it )
+    (*it)->startTest( test );
+}
+
+  
+void 
+TestResult::endTest( Test *test )
+{ 
+  ExclusiveZone zone( m_syncObject ); 
+  for ( TestListeners::iterator it = m_listeners.begin();
+        it != m_listeners.end(); 
+        ++it )
+    (*it)->endTest( test );
+}
+
+
+void 
+TestResult::startSuite( Test *test )
+{
+  ExclusiveZone zone( m_syncObject ); 
+  for ( TestListeners::iterator it = m_listeners.begin();
+        it != m_listeners.end(); 
+        ++it )
+    (*it)->startSuite( test );
+}
+
+
+void 
+TestResult::endSuite( Test *test )
+{
+  ExclusiveZone zone( m_syncObject ); 
+  for ( TestListeners::iterator it = m_listeners.begin();
+        it != m_listeners.end(); 
+        ++it )
+    (*it)->endSuite( test );
+}
+
+
+bool 
+TestResult::shouldStop() const
+{ 
+  ExclusiveZone zone( m_syncObject );
+  return m_stop; 
+}
+
+
+void 
+TestResult::stop()
+{ 
+  ExclusiveZone zone( m_syncObject );
+  m_stop = true; 
+}
+
+
+void 
+TestResult::addListener( TestListener *listener )
+{
+  ExclusiveZone zone( m_syncObject ); 
+  m_listeners.push_back( listener );
+}
+
+
+void 
+TestResult::removeListener ( TestListener *listener )
+{
+  ExclusiveZone zone( m_syncObject ); 
+  removeFromSequence( m_listeners, listener );
+}
+
+
+void 
+TestResult::runTest( Test *test )
+{
+  startTestRun( test );
+  test->run( this );
+  endTestRun( test );
+}
+
+
+void 
+TestResult::startTestRun( Test *test )
+{
+  ExclusiveZone zone( m_syncObject ); 
+  for ( TestListeners::iterator it = m_listeners.begin();
+        it != m_listeners.end(); 
+        ++it )
+    (*it)->startTestRun( test, this );
+}
+
+
+void 
+TestResult::endTestRun( Test *test )
+{
+  ExclusiveZone zone( m_syncObject ); 
+  for ( TestListeners::iterator it = m_listeners.begin();
+        it != m_listeners.end(); 
+        ++it )
+    (*it)->endTestRun( test, this );
+}
+
+
+bool 
+TestResult::protect( const Functor &functor,
+                     Test *test,
+                     const std::string &shortDescription )
+{
+  ProtectorContext context( test, this, shortDescription );
+  return m_protectorChain->protect( functor, context );
+}
+
+
+void 
+TestResult::pushProtector( Protector *protector )
+{
+  m_protectorChain->push( protector );
+}
+
+
+void 
+TestResult::popProtector()
+{
+  m_protectorChain->pop();
+}
+
+
+CPPUNIT_NS_END
diff --git a/3rdParty/CppUnit/src/src/cppunit/TestResultCollector.cpp b/3rdParty/CppUnit/src/src/cppunit/TestResultCollector.cpp
new file mode 100644
index 0000000..4371c50
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/TestResultCollector.cpp
@@ -0,0 +1,117 @@
+#include <cppunit/TestFailure.h>
+#include <cppunit/TestResultCollector.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+TestResultCollector::TestResultCollector( SynchronizationObject *syncObject )
+    : TestSuccessListener( syncObject )
+{
+  reset();
+}
+
+
+TestResultCollector::~TestResultCollector()
+{
+  freeFailures();
+}
+
+
+void 
+TestResultCollector::freeFailures()
+{
+  TestFailures::iterator itFailure = m_failures.begin();
+  while ( itFailure != m_failures.end() )
+    delete *itFailure++;
+  m_failures.clear();
+}
+
+
+void 
+TestResultCollector::reset()
+{
+  TestSuccessListener::reset();
+
+  ExclusiveZone zone( m_syncObject ); 
+  freeFailures();
+  m_testErrors = 0;
+  m_tests.clear();
+}
+
+
+void 
+TestResultCollector::startTest( Test *test )
+{
+  ExclusiveZone zone (m_syncObject); 
+  m_tests.push_back( test );
+}
+
+
+void 
+TestResultCollector::addFailure( const TestFailure &failure )
+{
+  TestSuccessListener::addFailure( failure );
+
+  ExclusiveZone zone( m_syncObject ); 
+  if ( failure.isError() )
+    ++m_testErrors;
+  m_failures.push_back( failure.clone() );
+}
+
+
+/// Gets the number of run tests.
+int 
+TestResultCollector::runTests() const
+{ 
+  ExclusiveZone zone( m_syncObject ); 
+  return m_tests.size(); 
+}
+
+
+/// Gets the number of detected errors (uncaught exception).
+int 
+TestResultCollector::testErrors() const
+{ 
+  ExclusiveZone zone( m_syncObject );
+  return m_testErrors;
+}
+
+
+/// Gets the number of detected failures (failed assertion).
+int 
+TestResultCollector::testFailures() const
+{ 
+  ExclusiveZone zone( m_syncObject ); 
+  return m_failures.size() - m_testErrors;
+}
+
+
+/// Gets the total number of detected failures.
+int 
+TestResultCollector::testFailuresTotal() const
+{
+  ExclusiveZone zone( m_syncObject ); 
+  return m_failures.size();
+}
+
+
+/// Returns a the list failures (random access collection).
+const TestResultCollector::TestFailures & 
+TestResultCollector::failures() const
+{ 
+  ExclusiveZone zone( m_syncObject );
+  return m_failures; 
+}
+
+
+const TestResultCollector::Tests &
+TestResultCollector::tests() const
+{
+  ExclusiveZone zone( m_syncObject );
+  return m_tests;
+}
+
+
+CPPUNIT_NS_END
+
diff --git a/3rdParty/CppUnit/src/src/cppunit/TestRunner.cpp b/3rdParty/CppUnit/src/src/cppunit/TestRunner.cpp
new file mode 100644
index 0000000..8d95a63
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/TestRunner.cpp
@@ -0,0 +1,101 @@
+#include <cppunit/config/SourcePrefix.h>
+#include <cppunit/TestRunner.h>
+#include <cppunit/TestPath.h>
+#include <cppunit/TestResult.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+TestRunner::WrappingSuite::WrappingSuite( const std::string &name ) 
+    : TestSuite( name )
+{
+}
+
+
+int 
+TestRunner::WrappingSuite::getChildTestCount() const
+{
+  if ( hasOnlyOneTest() )
+    return getUniqueChildTest()->getChildTestCount();
+  return TestSuite::getChildTestCount();
+}
+
+
+std::string 
+TestRunner::WrappingSuite::getName() const
+{
+  if ( hasOnlyOneTest() )
+    return getUniqueChildTest()->getName();
+  return TestSuite::getName();
+}
+
+
+Test *
+TestRunner::WrappingSuite::doGetChildTestAt( int index ) const
+{
+  if ( hasOnlyOneTest() )
+    return getUniqueChildTest()->getChildTestAt( index );
+  return TestSuite::doGetChildTestAt( index );
+}
+
+
+void 
+TestRunner::WrappingSuite::run( TestResult *result )
+{
+  if ( hasOnlyOneTest() )
+    getUniqueChildTest()->run( result );
+  else
+    TestSuite::run( result );
+}
+
+
+bool 
+TestRunner::WrappingSuite::hasOnlyOneTest() const
+{
+  return TestSuite::getChildTestCount() == 1;
+}
+
+
+Test *
+TestRunner::WrappingSuite::getUniqueChildTest() const
+{
+  return TestSuite::doGetChildTestAt( 0 );
+}
+
+
+
+
+
+TestRunner::TestRunner()
+    : m_suite( new WrappingSuite() )
+{
+}
+
+
+TestRunner::~TestRunner()
+{
+  delete m_suite;
+}
+
+
+void 
+TestRunner::addTest( Test *test )
+{
+  m_suite->addTest( test ); 
+}
+
+
+void 
+TestRunner::run( TestResult &controller,
+                 const std::string &testPath )
+{
+  TestPath path = m_suite->resolveTestPath( testPath );
+  Test *testToRun = path.getChildTest();
+
+  controller.runTest( testToRun );
+}
+
+
+CPPUNIT_NS_END
+
diff --git a/3rdParty/CppUnit/src/src/cppunit/TestSuccessListener.cpp b/3rdParty/CppUnit/src/src/cppunit/TestSuccessListener.cpp
new file mode 100644
index 0000000..a5572a9
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/TestSuccessListener.cpp
@@ -0,0 +1,44 @@
+#include <cppunit/TestSuccessListener.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+TestSuccessListener::TestSuccessListener( SynchronizationObject *syncObject )
+    : SynchronizedObject( syncObject )
+    , m_success( true )
+{
+}
+
+
+TestSuccessListener::~TestSuccessListener()
+{
+}
+
+
+void 
+TestSuccessListener::reset()
+{
+  ExclusiveZone zone( m_syncObject );
+  m_success = true;
+}
+
+
+void 
+TestSuccessListener::addFailure( const TestFailure & )
+{
+  ExclusiveZone zone( m_syncObject );
+  m_success = false;
+}
+
+
+bool 
+TestSuccessListener::wasSuccessful() const
+{
+  ExclusiveZone zone( m_syncObject );
+  return m_success;
+}
+
+
+CPPUNIT_NS_END
+
diff --git a/3rdParty/CppUnit/src/src/cppunit/TestSuite.cpp b/3rdParty/CppUnit/src/src/cppunit/TestSuite.cpp
new file mode 100644
index 0000000..8dd2ea6
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/TestSuite.cpp
@@ -0,0 +1,64 @@
+#include <cppunit/config/SourcePrefix.h>
+#include <cppunit/TestSuite.h>
+#include <cppunit/TestResult.h>
+
+CPPUNIT_NS_BEGIN
+
+
+/// Default constructor
+TestSuite::TestSuite( std::string name )
+    : TestComposite( name )
+{
+}
+
+
+/// Destructor
+TestSuite::~TestSuite()
+{ 
+  deleteContents(); 
+}
+
+
+/// Deletes all tests in the suite.
+void 
+TestSuite::deleteContents()
+{
+  int childCount = getChildTestCount();
+  for ( int index =0; index < childCount; ++index )
+    delete getChildTestAt( index );
+
+  m_tests.clear();
+}
+
+
+/// Adds a test to the suite. 
+void 
+TestSuite::addTest( Test *test )
+{ 
+  m_tests.push_back( test ); 
+}
+
+
+const CppUnitVector<Test *> &
+TestSuite::getTests() const
+{
+  return m_tests;
+}
+
+
+int 
+TestSuite::getChildTestCount() const
+{
+  return m_tests.size();
+}
+
+
+Test *
+TestSuite::doGetChildTestAt( int index ) const
+{
+  return m_tests[index];
+}
+
+
+CPPUNIT_NS_END
+
diff --git a/3rdParty/CppUnit/src/src/cppunit/TestSuiteBuilderContext.cpp b/3rdParty/CppUnit/src/src/cppunit/TestSuiteBuilderContext.cpp
new file mode 100644
index 0000000..ff71b52
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/TestSuiteBuilderContext.cpp
@@ -0,0 +1,85 @@
+#include <cppunit/TestSuite.h>
+#include <cppunit/extensions/TestFixtureFactory.h>
+#include <cppunit/extensions/TestNamer.h>
+#include <cppunit/extensions/TestSuiteBuilderContext.h>
+
+
+CPPUNIT_NS_BEGIN
+
+TestSuiteBuilderContextBase::TestSuiteBuilderContextBase( 
+                                 TestSuite &suite,
+                                 const TestNamer &namer,
+                                 TestFixtureFactory &factory )
+  : m_suite( suite )
+  , m_namer( namer )
+  , m_factory( factory )
+{
+}
+
+
+TestSuiteBuilderContextBase::~TestSuiteBuilderContextBase()
+{
+}
+
+
+void 
+TestSuiteBuilderContextBase::addTest( Test *test )
+{
+  m_suite.addTest( test );
+}
+
+
+std::string 
+TestSuiteBuilderContextBase::getFixtureName() const
+{
+  return m_namer.getFixtureName();
+}
+
+
+std::string 
+TestSuiteBuilderContextBase::getTestNameFor( 
+                                 const std::string &testMethodName ) const
+{
+  return m_namer.getTestNameFor( testMethodName );
+}
+
+
+TestFixture *
+TestSuiteBuilderContextBase::makeTestFixture() const
+{
+  return m_factory.makeFixture();
+}
+
+
+void 
+TestSuiteBuilderContextBase::addProperty( const std::string &key, 
+                                          const std::string &value )
+{
+  Properties::iterator it = m_properties.begin();
+  for ( ; it != m_properties.end(); ++it )
+  {
+    if ( (*it).first == key )
+    {
+      (*it).second = value;
+      return;
+    }
+  }
+
+  Property property( key, value );
+  m_properties.push_back( property );
+}
+
+const std::string 
+TestSuiteBuilderContextBase::getStringProperty( const std::string &key ) const
+{
+  Properties::const_iterator it = m_properties.begin();
+  for ( ; it != m_properties.end(); ++it )
+  {
+    if ( (*it).first == key )
+      return (*it).second;
+  }
+  return "";
+}
+
+
+CPPUNIT_NS_END
diff --git a/3rdParty/CppUnit/src/src/cppunit/TextOutputter.cpp b/3rdParty/CppUnit/src/src/cppunit/TextOutputter.cpp
new file mode 100644
index 0000000..f74214f
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/TextOutputter.cpp
@@ -0,0 +1,140 @@
+#include <cppunit/Exception.h>
+#include <cppunit/SourceLine.h>
+#include <cppunit/TestFailure.h>
+#include <cppunit/TextOutputter.h>
+#include <cppunit/TestResultCollector.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+TextOutputter::TextOutputter( TestResultCollector *result,
+                              OStream &stream )
+    : m_result( result )
+    , m_stream( stream )
+{
+}
+
+
+TextOutputter::~TextOutputter()
+{
+}
+
+
+void 
+TextOutputter::write() 
+{
+  printHeader();
+  m_stream << "\n";
+  printFailures();
+  m_stream << "\n";
+}
+
+
+void 
+TextOutputter::printFailures()
+{
+  TestResultCollector::TestFailures::const_iterator itFailure = m_result->failures().begin();
+  int failureNumber = 1;
+  while ( itFailure != m_result->failures().end() ) 
+  {
+    m_stream  <<  "\n";
+    printFailure( *itFailure++, failureNumber++ );
+  }
+}
+
+
+void 
+TextOutputter::printFailure( TestFailure *failure,
+                             int failureNumber )
+{
+  printFailureListMark( failureNumber );
+  m_stream << ' ';
+  printFailureTestName( failure );
+  m_stream << ' ';
+  printFailureType( failure );
+  m_stream << ' ';
+  printFailureLocation( failure->sourceLine() );
+  m_stream << "\n";
+  printFailureDetail( failure->thrownException() );
+  m_stream << "\n";
+}
+
+
+void 
+TextOutputter::printFailureListMark( int failureNumber )
+{
+  m_stream << failureNumber << ")";
+}
+
+
+void 
+TextOutputter::printFailureTestName( TestFailure *failure )
+{
+  m_stream << "test: " << failure->failedTestName();
+}
+
+
+void 
+TextOutputter::printFailureType( TestFailure *failure )
+{
+  m_stream << "("
+           << (failure->isError() ? "E" : "F")
+           << ")";
+}
+
+
+void 
+TextOutputter::printFailureLocation( SourceLine sourceLine )
+{
+  if ( !sourceLine.isValid() )
+    return;
+
+  m_stream << "line: " << sourceLine.lineNumber()
+           << ' ' << sourceLine.fileName();
+}
+
+
+void 
+TextOutputter::printFailureDetail( Exception *thrownException )
+{
+  m_stream  <<  thrownException->message().shortDescription()  <<  "\n";
+  m_stream  <<  thrownException->message().details();
+}
+
+
+void 
+TextOutputter::printHeader()
+{
+  if ( m_result->wasSuccessful() )
+    m_stream << "\nOK (" << m_result->runTests () << " tests)\n" ;
+  else
+  {
+    m_stream << "\n";
+    printFailureWarning();
+    printStatistics();
+  }
+}
+
+
+void 
+TextOutputter::printFailureWarning()
+{
+  m_stream  << "!!!FAILURES!!!\n";
+}
+
+
+void 
+TextOutputter::printStatistics()
+{
+  m_stream  << "Test Results:\n";
+
+  m_stream  <<  "Run:  "  <<  m_result->runTests()
+            <<  "   Failures: "  <<  m_result->testFailures()
+            <<  "   Errors: "  <<  m_result->testErrors()
+            <<  "\n";
+}
+
+
+CPPUNIT_NS_END
+
diff --git a/3rdParty/CppUnit/src/src/cppunit/TextTestProgressListener.cpp b/3rdParty/CppUnit/src/src/cppunit/TextTestProgressListener.cpp
new file mode 100644
index 0000000..5bbe768
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/TextTestProgressListener.cpp
@@ -0,0 +1,43 @@
+#include <cppunit/TestFailure.h>
+#include <cppunit/TextTestProgressListener.h>
+#include <cppunit/portability/Stream.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+TextTestProgressListener::TextTestProgressListener()
+{
+}
+
+
+TextTestProgressListener::~TextTestProgressListener()
+{
+}
+
+
+void 
+TextTestProgressListener::startTest( Test * )
+{
+  stdCOut() << ".";
+}
+
+
+void 
+TextTestProgressListener::addFailure( const TestFailure &failure )
+{
+  stdCOut() << ( failure.isError() ? "E" : "F" );
+}
+
+
+void 
+TextTestProgressListener::endTestRun( Test *, 
+                                      TestResult * )
+{
+  stdCOut()  <<  "\n";
+  stdCOut().flush();
+}
+
+
+CPPUNIT_NS_END
+
diff --git a/3rdParty/CppUnit/src/src/cppunit/TextTestRunner.cpp b/3rdParty/CppUnit/src/src/cppunit/TextTestRunner.cpp
new file mode 100644
index 0000000..1534ec0
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/TextTestRunner.cpp
@@ -0,0 +1,144 @@
+// ==> Implementation of cppunit/ui/text/TestRunner.h
+
+#include <cppunit/config/SourcePrefix.h>
+#include <cppunit/TestSuite.h>
+#include <cppunit/TextTestResult.h>
+#include <cppunit/TextOutputter.h>
+#include <cppunit/TextTestProgressListener.h>
+#include <cppunit/TestResult.h>
+#include <cppunit/ui/text/TextTestRunner.h>
+#include <cppunit/portability/Stream.h>
+#include <stdexcept>
+
+
+CPPUNIT_NS_BEGIN
+
+
+/*! Constructs a new text runner.
+ * \param outputter used to print text result. Owned by the runner.
+ */
+TextTestRunner::TextTestRunner( Outputter *outputter ) 
+    : m_result( new TestResultCollector() )
+    , m_eventManager( new TestResult() )
+    , m_outputter( outputter )
+{
+  if ( !m_outputter )
+    m_outputter = new TextOutputter( m_result, stdCOut() );
+  m_eventManager->addListener( m_result );
+}
+
+
+TextTestRunner::~TextTestRunner()
+{
+  delete m_eventManager;
+  delete m_outputter;
+  delete m_result;
+}
+
+
+/*! Runs the named test case.
+ *
+ * \param testName Name of the test case to run. If an empty is given, then
+ *                 all added tests are run. The name can be the name of any
+ *                 test in the hierarchy.
+ * \param doWait if \c true then the user must press the RETURN key 
+ *               before the run() method exit.
+ * \param doPrintResult if \c true (default) then the test result are printed
+ *                      on the standard output.
+ * \param doPrintProgress if \c true (default) then TextTestProgressListener is
+ *                        used to show the progress.
+ * \return \c true is the test was successful, \c false if the test
+ *         failed or was not found.
+ */
+bool
+TextTestRunner::run( std::string testName,
+                       bool doWait,
+                       bool doPrintResult,
+                       bool doPrintProgress )
+{
+  TextTestProgressListener progress;
+  if ( doPrintProgress )
+    m_eventManager->addListener( &progress );
+
+  TestRunner *pThis = this;
+  pThis->run( *m_eventManager, testName );
+
+  if ( doPrintProgress )
+    m_eventManager->removeListener( &progress );
+
+  printResult( doPrintResult );
+  wait( doWait );
+
+  return m_result->wasSuccessful();
+}
+
+
+void 
+TextTestRunner::wait( bool doWait )
+{
+#if !defined( CPPUNIT_NO_STREAM )
+  if ( doWait ) 
+  {
+    stdCOut() << "<RETURN> to continue\n";
+    stdCOut().flush();
+    std::cin.get ();
+  }
+#endif
+}
+
+
+void 
+TextTestRunner::printResult( bool doPrintResult )
+{
+  stdCOut() << "\n";
+  if ( doPrintResult )
+    m_outputter->write();
+}
+
+
+/*! Returns the result of the test run.
+ * Use this after calling run() to access the result of the test run.
+ */
+TestResultCollector &
+TextTestRunner::result() const
+{
+  return *m_result;
+}
+
+
+/*! Returns the event manager.
+ * The instance of TestResult results returned is the one that is used to run the
+ * test. Use this to register additional TestListener before running the tests.
+ */
+TestResult &
+TextTestRunner::eventManager() const
+{
+  return *m_eventManager;
+}
+
+
+/*! Specifies an alternate outputter.
+ *
+ * Notes that the outputter will be use after the test run only if \a printResult was
+ * \c true.
+ * \param outputter New outputter to use. The previous outputter is destroyed. 
+ *                  The TextTestRunner assumes ownership of the outputter.
+ * \see CompilerOutputter, XmlOutputter, TextOutputter.
+ */
+void 
+TextTestRunner::setOutputter( Outputter *outputter )
+{
+  delete m_outputter;
+  m_outputter = outputter;
+}
+
+
+void 
+TextTestRunner::run( TestResult &controller,
+                     const std::string &testPath )
+{
+  TestRunner::run( controller, testPath );
+}
+
+
+CPPUNIT_NS_END
diff --git a/3rdParty/CppUnit/src/src/cppunit/TypeInfoHelper.cpp b/3rdParty/CppUnit/src/src/cppunit/TypeInfoHelper.cpp
new file mode 100644
index 0000000..2febac6
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/TypeInfoHelper.cpp
@@ -0,0 +1,54 @@
+#include <cppunit/Portability.h>
+#include <cppunit/extensions/TypeInfoHelper.h>
+#include <stdlib.h>
+
+#if CPPUNIT_HAVE_RTTI
+
+#include <string>
+
+#if CPPUNIT_HAVE_GCC_ABI_DEMANGLE
+#include <cxxabi.h>
+#endif
+
+
+CPPUNIT_NS_BEGIN
+
+
+std::string 
+TypeInfoHelper::getClassName( const std::type_info &info )
+{
+#if defined(CPPUNIT_HAVE_GCC_ABI_DEMANGLE)  &&  CPPUNIT_HAVE_GCC_ABI_DEMANGLE
+
+  int status = 0;
+  char* c_name = 0;
+
+  c_name = abi::__cxa_demangle( info.name(), 0, 0, &status );
+  
+  std::string name( c_name );
+  free( c_name );  
+
+#else   // CPPUNIT_HAVE_GCC_ABI_DEMANGLE
+
+  static std::string classPrefix( "class " );
+  std::string name( info.name() );
+
+  // Work around gcc 3.0 bug: strip number before type name.
+  unsigned int firstNotDigitIndex = 0;
+  while ( firstNotDigitIndex < name.length()  &&
+          name[firstNotDigitIndex] >= '0'  &&
+          name[firstNotDigitIndex] <= '9' )
+    ++firstNotDigitIndex;
+  name = name.substr( firstNotDigitIndex );
+
+  if ( name.substr( 0, classPrefix.length() ) == classPrefix )
+    return name.substr( classPrefix.length() );
+
+#endif  // CPPUNIT_HAVE_GCC_ABI_DEMANGLE
+
+  return name;
+}
+
+
+CPPUNIT_NS_END
+
+#endif // CPPUNIT_HAVE_RTTI
diff --git a/3rdParty/CppUnit/src/src/cppunit/XmlDocument.cpp b/3rdParty/CppUnit/src/src/cppunit/XmlDocument.cpp
new file mode 100644
index 0000000..31f9115
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/XmlDocument.cpp
@@ -0,0 +1,106 @@
+#include <cppunit/config/SourcePrefix.h>
+#include <cppunit/tools/XmlDocument.h>
+#include <cppunit/tools/XmlElement.h>
+
+
+CPPUNIT_NS_BEGIN
+
+
+XmlDocument::XmlDocument( const std::string &encoding,
+                          const std::string &styleSheet )
+  : m_styleSheet( styleSheet )
+  , m_rootElement( new XmlElement( "DummyRoot" ) )
+  , m_standalone( true )
+{
+  setEncoding( encoding );
+}
+
+
+XmlDocument::~XmlDocument()
+{
+  delete m_rootElement;
+}
+
+
+
+std::string 
+XmlDocument::encoding() const
+{
+  return m_encoding;
+}
+
+
+void 
+XmlDocument::setEncoding( const std::string &encoding )
+{
+  m_encoding = encoding.empty() ? std::string("ISO-8859-1") : encoding;
+}
+
+
+std::string 
+XmlDocument::styleSheet() const
+{
+  return m_styleSheet;
+}
+
+
+void 
+XmlDocument::setStyleSheet( const std::string &styleSheet )
+{
+  m_styleSheet = styleSheet;
+}
+
+
+bool
+XmlDocument::standalone() const
+{
+  return m_standalone;
+}
+
+
+void
+XmlDocument::setStandalone( bool standalone )
+{
+  m_standalone = standalone;
+}
+
+
+void 
+XmlDocument::setRootElement( XmlElement *rootElement )
+{
+  if ( rootElement == m_rootElement )
+    return;
+
+  delete m_rootElement;
+  m_rootElement = rootElement;
+}
+
+
+XmlElement &
+XmlDocument::rootElement() const
+{
+  return *m_rootElement;
+}
+
+
+std::string 
+XmlDocument::toString() const
+{
+  std::string asString = "<?xml version=\"1.0\" "
+                         "encoding='" + m_encoding + "'";
+  if ( m_standalone )
+      asString += " standalone='yes'";
+
+  asString += " ?>\n"; 
+
+  if ( !m_styleSheet.empty() )
+    asString += "<?xml-stylesheet type=\"text/xsl\" href=\"" + m_styleSheet + "\"?>\n";
+
+  asString += m_rootElement->toString();
+
+  return asString;
+}
+
+
+CPPUNIT_NS_END
+
diff --git a/3rdParty/CppUnit/src/src/cppunit/XmlElement.cpp b/3rdParty/CppUnit/src/src/cppunit/XmlElement.cpp
new file mode 100644
index 0000000..f930ad4
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/XmlElement.cpp
@@ -0,0 +1,226 @@
+#include <cppunit/tools/StringTools.h>
+#include <cppunit/tools/XmlElement.h>
+#include <stdexcept>
+
+
+CPPUNIT_NS_BEGIN
+
+  
+XmlElement::XmlElement( std::string elementName,
+                        std::string content ) 
+  : m_name( elementName )
+  , m_content( content )
+{
+}
+
+    
+XmlElement::XmlElement( std::string elementName,
+                        int numericContent )
+  : m_name( elementName )
+{
+  setContent( numericContent );
+}
+
+
+XmlElement::~XmlElement()
+{
+  Elements::iterator itNode = m_elements.begin();
+  while ( itNode != m_elements.end() )
+  {
+    XmlElement *element = *itNode++;
+    delete element;
+  }
+}
+
+
+std::string 
+XmlElement::name() const
+{
+  return m_name;
+}
+
+
+std::string 
+XmlElement::content() const
+{
+  return m_content;
+}
+
+
+void 
+XmlElement::setName( const std::string &name )
+{
+  m_name = name;
+}
+
+
+void 
+XmlElement::setContent( const std::string &content )
+{
+  m_content = content;
+}
+
+
+void 
+XmlElement::setContent( int numericContent )
+{
+  m_content = StringTools::toString( numericContent );
+}
+
+
+void 
+XmlElement::addAttribute( std::string attributeName,
+                          std::string value  )
+{
+  m_attributes.push_back( Attribute( attributeName, value ) );
+}
+
+
+void 
+XmlElement::addAttribute( std::string attributeName,
+                          int numericValue )
+{
+  addAttribute( attributeName, StringTools::toString( numericValue ) );
+}
+
+
+void 
+XmlElement::addElement( XmlElement *node )
+{
+  m_elements.push_back( node );
+}
+
+
+int 
+XmlElement::elementCount() const
+{
+  return m_elements.size();
+}
+
+
+XmlElement *
+XmlElement::elementAt( int index ) const
+{
+  if ( index < 0  ||  index >= elementCount() )
+    throw std::invalid_argument( "XmlElement::elementAt(), out of range index" );
+
+  return m_elements[ index ];
+}
+
+
+XmlElement *
+XmlElement::elementFor( const std::string &name ) const
+{
+  Elements::const_iterator itElement = m_elements.begin();
+  for ( ; itElement != m_elements.end(); ++itElement )
+  {
+    if ( (*itElement)->name() == name )
+      return *itElement;
+  }
+
+  throw std::invalid_argument( "XmlElement::elementFor(), not matching child element found" );
+  return NULL;  // make some compilers happy.
+}
+
+
+std::string 
+XmlElement::toString( const std::string &indent ) const
+{
+  std::string element( indent );
+  element += "<";
+  element += m_name;
+  if ( !m_attributes.empty() )
+  {
+    element += " ";
+    element += attributesAsString();
+  }
+  element += ">";
+
+  if ( !m_elements.empty() )
+  {
+    element += "\n";
+
+    std::string subNodeIndent( indent + "  " );
+    Elements::const_iterator itNode = m_elements.begin();
+    while ( itNode != m_elements.end() )
+    {
+      const XmlElement *node = *itNode++;
+      element += node->toString( subNodeIndent );
+    }
+
+    element += indent;
+  }
+
+  if ( !m_content.empty() )
+  {
+    element += escape( m_content );
+    if ( !m_elements.empty() )
+    {
+      element += "\n";
+      element += indent;
+    }
+  }
+
+  element += "</";
+  element += m_name;
+  element += ">\n";
+
+  return element;
+}
+
+
+std::string 
+XmlElement::attributesAsString() const
+{
+  std::string attributes;
+  Attributes::const_iterator itAttribute = m_attributes.begin();
+  while ( itAttribute != m_attributes.end() )
+  {
+    if ( !attributes.empty() )
+       attributes += " ";
+
+    const Attribute &attribute = *itAttribute++;
+    attributes += attribute.first;
+    attributes += "=\"";
+    attributes += escape( attribute.second );
+    attributes += "\"";
+  }
+  return attributes;
+}
+
+
+std::string 
+XmlElement::escape( std::string value ) const
+{
+  std::string escaped;
+  for ( unsigned int index =0; index < value.length(); ++index )
+  {
+    char c = value[index ];
+    switch ( c )    // escape all predefined XML entity (safe?)
+    {
+    case '<': 
+      escaped += "&lt;";
+      break;
+    case '>': 
+      escaped += "&gt;";
+      break;
+    case '&': 
+      escaped += "&amp;";
+      break;
+    case '\'': 
+      escaped += "&apos;";
+      break;
+    case '"': 
+      escaped += "&quot;";
+      break;
+    default:
+      escaped += c;
+    }
+  }
+  
+  return escaped;
+}
+
+
+CPPUNIT_NS_END
+
diff --git a/3rdParty/CppUnit/src/src/cppunit/XmlOutputter.cpp b/3rdParty/CppUnit/src/src/cppunit/XmlOutputter.cpp
new file mode 100644
index 0000000..c605e33
--- /dev/null
+++ b/3rdParty/CppUnit/src/src/cppunit/XmlOutputter.cpp
@@ -0,0 +1,205 @@
+#include <cppunit/Exception.h>
+#include <cppunit/Test.h>
+#include <cppunit/TestFailure.h>
+#include <cppunit/TestResultCollector.h>
+#include <cppunit/XmlOutputter.h>
+#include <cppunit/XmlOutputterHook.h>
+#include <cppunit/tools/XmlDocument.h>
+#include <cppunit/tools/XmlElement.h>
+#include <stdlib.h>
+#include <algorithm>
+
+
+CPPUNIT_NS_BEGIN
+
+
+XmlOutputter::XmlOutputter( TestResultCollector *result,
+                            OStream &stream,
+                            std::string encoding )
+  : m_result( result )
+  , m_stream( stream )
+  , m_xml( new XmlDocument( encoding ) )
+{
+}
+
+
+XmlOutputter::~XmlOutputter()
+{
+  delete m_xml;
+}
+
+
+void 
+XmlOutputter::addHook( XmlOutputterHook *hook )
+{
+  m_hooks.push_back( hook );
+}
+
+
+void 
+XmlOutputter::removeHook( XmlOutputterHook *hook )
+{
+  m_hooks.erase( std::find( m_hooks.begin(), m_hooks.end(), hook ) );
+}
+
+
+void 
+XmlOutputter::write()
+{
+  setRootNode();
+  m_stream  <<  m_xml->toString();
+}
+
+
+void 
+XmlOutputter::setStyleSheet( const std::string &styleSheet )
+{
+  m_xml->setStyleSheet( styleSheet );
+}
+
+
+void
+XmlOutputter::setStandalone( bool standalone )
+{
+  m_xml->setStandalone( standalone );
+}
+ 
+
+void
+XmlOutputter::setRootNode()
+{
+  XmlElement *rootNode = new XmlElement( "TestRun" );
+  m_xml->setRootElement( rootNode );
+
+  for ( Hooks::iterator it = m_hooks.begin(); it != m_hooks.end(); ++it )
+    (*it)->beginDocument( m_xml );
+
+  FailedTests failedTests;
+  fillFailedTestsMap( failedTests );
+
+  addFailedTests( failedTests, rootNode );
+  addSuccessfulTests( failedTests, rootNode );
+  addStatistics( rootNode );
+
+  for ( Hooks::iterator itEnd = m_hooks.begin(); itEnd != m_hooks.end(); ++itEnd )
+    (*itEnd)->endDocument( m_xml );
+}
+
+
+void 
+XmlOutputter::fillFailedTestsMap( FailedTests &failedTests )
+{
+  const TestResultCollector::TestFailures &failures = m_result->failures();
+  TestResultCollector::TestFailures::const_iterator itFailure = failures.begin();
+  while ( itFailure != failures.end() )
+  {
+    TestFailure *failure = *itFailure++;
+    failedTests.insert( std::pair<Test* const, TestFailure*>(failure->failedTest(), failure ) );
+  }
+}
+
+
+void
+XmlOutputter::addFailedTests( FailedTests &failedTests,
+                              XmlElement *rootNode )
+{
+  XmlElement *testsNode = new XmlElement( "FailedTests" );
+  rootNode->addElement( testsNode );
+
+  const TestResultCollector::Tests &tests = m_result->tests();
+  for ( unsigned int testNumber = 0; testNumber < tests.size(); ++testNumber )
+  {
+    Test *test = tests[testNumber];
+    if ( failedTests.find( test ) != failedTests.end() )
+      addFailedTest( test, failedTests[test], testNumber+1, testsNode );
+  }
+}
+
+
+void
+XmlOutputter::addSuccessfulTests( FailedTests &failedTests,
+                                           XmlElement *rootNode )
+{
+  XmlElement *testsNode = new XmlElement( "SuccessfulTests" );
+  rootNode->addElement( testsNode );
+
+  const TestResultCollector::Tests &tests = m_result->tests();
+  for ( unsigned int testNumber = 0; testNumber < tests.size(); ++testNumber )
+  {
+    Test *test = tests[testNumber];
+    if ( failedTests.find( test ) == failedTests.end() )
+      addSuccessfulTest( test, testNumber+1, testsNode );
+  }
+}
+
+
+void
+XmlOutputter::addStatistics( XmlElement *rootNode )
+{
+  XmlElement *statisticsElement = new XmlElement( "Statistics" );
+  rootNode->addElement( statisticsElement );
+  statisticsElement->addElement( new XmlElement( "Tests", m_result->runTests() ) );
+  statisticsElement->addElement( new XmlElement( "FailuresTotal", 
+                                                 m_result->testFailuresTotal() ) );
+  statisticsElement->addElement( new XmlElement( "Errors", m_result->testErrors() ) );
+  statisticsElement->addElement( new XmlElement( "Failures", m_result->testFailures() ) );
+
+  for ( Hooks::iterator it = m_hooks.begin(); it != m_hooks.end(); ++it )
+    (*it)->statisticsAdded( m_xml, statisticsElement );
+}
+
+
+void
+XmlOutputter::addFailedTest( Test *test,
+                             TestFailure *failure,
+                             int testNumber,
+                             XmlElement *testsNode )
+{
+  Exception *thrownException = failure->thrownException();
+  
+  XmlElement *testElement = new XmlElement( "FailedTest" );
+  testsNode->addElement( testElement );
+  testElement->addAttribute( "id", testNumber );
+  testElement->addElement( new XmlElement( "Name", test->getName() ) );
+  testElement->addElement( new XmlElement( "FailureType", 
+                                           failure->isError() ? "Error" : 
+                                                                "Assertion" ) );
+
+  if ( failure->sourceLine().isValid() )
+    addFailureLocation( failure, testElement );
+
+  testElement->addElement( new XmlElement( "Message", thrownException->what() ) );
+
+  for ( Hooks::iterator it = m_hooks.begin(); it != m_hooks.end(); ++it )
+    (*it)->failTestAdded( m_xml, testElement, test, failure );
+}
+
+
+void
+XmlOutputter::addFailureLocation( TestFailure *failure,
+                                  XmlElement *testElement )
+{
+  XmlElement *locationNode = new XmlElement( "Location" );
+  testElement->addElement( locationNode );
+  SourceLine sourceLine = failure->sourceLine();
+  locationNode->addElement( new XmlElement( "File", sourceLine.fileName() ) );
+  locationNode->addElement( new XmlElement( "Line", sourceLine.lineNumber() ) );
+}
+
+
+void
+XmlOutputter::addSuccessfulTest( Test *test, 
+                                 int testNumber,
+                                 XmlElement *testsNode )
+{
+  XmlElement *testElement = new XmlElement( "Test" );
+  testsNode->addElement( testElement );
+  testElement->addAttribute( "id", testNumber );
+  testElement->addElement( new XmlElement( "Name", test->getName() ) );
+
+  for ( Hooks::iterator it = m_hooks.begin(); it != m_hooks.end(); ++it )
+    (*it)->successfulTestAdded( m_xml, testElement, test );
+}
+
+
+CPPUNIT_NS_END
author	Remko Tronçon <git@el-tramo.be>	2010-03-28 15:46:49 (GMT)
committer	Remko Tronçon <git@el-tramo.be>	2010-03-28 15:46:49 (GMT)
commit	f53a1ef582494458301b97bf6e546be52d7ff7e8 (patch)
tree	7571b5cbcbd8a8f1dd1c966c9045b6cb69f0e295 /3rdParty/CppUnit
parent	638345680d72ca6acaf123f2c8c1c391f696e371 (diff)
download	swift-contrib-f53a1ef582494458301b97bf6e546be52d7ff7e8.zip swift-contrib-f53a1ef582494458301b97bf6e546be52d7ff7e8.tar.bz2