From 29a7f0390b6904e9b7c447d1e6e44442bd0ab17b Mon Sep 17 00:00:00 2001
From: Rene Rivera <grafikrobot@gmail.com>
Date: Fri, 7 Oct 2016 23:07:35 -0500
Subject: [PATCH 01/14] Add, and update, documentation build targets.

---
 doc/Jamfile.v2 | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/doc/Jamfile.v2 b/doc/Jamfile.v2
index 96601b7..47e1ebe 100644
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@@ -45,3 +45,13 @@ boostbook standalone
       <dependency>autodoc
       <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/property_tree/doc/html
     ;
+
+###############################################################################
+alias boostdoc
+    : property_tree
+    :
+    : <dependency>autodoc
+    : ;
+explicit boostdoc ;
+alias boostrelease ;
+explicit boostrelease ;

From 77c6fa693af0ba8300aec151de741e92901c55c3 Mon Sep 17 00:00:00 2001
From: tellenbach <david.tellenbach@tellnotes.org>
Date: Sun, 23 Dec 2018 15:26:22 +0100
Subject: [PATCH 02/14] Link to Wikipedia fixed. Former link pointed to
 disambiguation page.

---
 doc/ini_parser.qbk | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/ini_parser.qbk b/doc/ini_parser.qbk
index 560817a..670e121 100644
--- a/doc/ini_parser.qbk
+++ b/doc/ini_parser.qbk
@@ -6,7 +6,7 @@
  / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  /]
 [section INI Parser]
-[def __ini__ [@http://en.wikipedia.org/wiki/INI INI format]]
+[def __ini__ [@https://en.wikipedia.org/wiki/INI_file INI format]]
 The __ini__ was once widely used in the world of Windows. It is now deprecated,
 but is still used by a surprisingly large number of applications. The reason is
 probably its simplicity, plus that Microsoft recommends using the registry as

From d1c8825a45a0717e1ad79583d3283b0e5e32831e Mon Sep 17 00:00:00 2001
From: Andrey Semashev <Lastique@users.noreply.github.com>
Date: Tue, 28 Apr 2020 22:03:04 +0300
Subject: [PATCH 03/14] Fix usage of deprecated Boost.Bind features

This fixes deprecation warnings generated by boost/bind.hpp.

Also, use a more actual include path for ref.hpp.
---
 include/boost/property_tree/json_parser/detail/parser.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/boost/property_tree/json_parser/detail/parser.hpp b/include/boost/property_tree/json_parser/detail/parser.hpp
index 5554990..6cf6363 100644
--- a/include/boost/property_tree/json_parser/detail/parser.hpp
+++ b/include/boost/property_tree/json_parser/detail/parser.hpp
@@ -3,8 +3,8 @@
 
 #include <boost/property_tree/json_parser/error.hpp>
 
-#include <boost/ref.hpp>
-#include <boost/bind.hpp>
+#include <boost/core/ref.hpp>
+#include <boost/bind/bind.hpp>
 #include <boost/format.hpp>
 
 #include <iterator>
@@ -214,7 +214,7 @@ namespace boost { namespace property_tree {
         void process_codepoint(Sentinel end, EncodingErrorFn error_fn) {
             encoding.transcode_codepoint(cur, end,
                 boost::bind(&Callbacks::on_code_unit,
-                            boost::ref(callbacks), _1),
+                            boost::ref(callbacks), boost::placeholders::_1),
                 error_fn);
         }
 
@@ -517,7 +517,7 @@ namespace boost { namespace property_tree {
         void feed(unsigned codepoint) {
             encoding.feed_codepoint(codepoint,
                                     boost::bind(&Callbacks::on_code_unit,
-                                                boost::ref(callbacks), _1));
+                                                boost::ref(callbacks), boost::placeholders::_1));
         }
 
         Callbacks& callbacks;

From 0d3be8d532013f739fb098396130bcf7e144242b Mon Sep 17 00:00:00 2001
From: Eugene Zelenko <eugene@diakopto.com>
Date: Tue, 19 May 2020 15:41:23 -0700
Subject: [PATCH 04/14] Use BOOST_OVERRIDE to fix GCC -Wsuggest-override and
 Clang-tidy modernize-use-override warnings. Fix Clang-tidy
 modernize-use-bool-literals warnings and misspellings.

---
 .../detail/file_parser_error.hpp              |  2 +-
 .../boost/property_tree/detail/rapidxml.hpp   | 34 +++++++++----------
 include/boost/property_tree/exceptions.hpp    |  8 ++---
 3 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/include/boost/property_tree/detail/file_parser_error.hpp b/include/boost/property_tree/detail/file_parser_error.hpp
index ff90583..1a0e49a 100644
--- a/include/boost/property_tree/detail/file_parser_error.hpp
+++ b/include/boost/property_tree/detail/file_parser_error.hpp
@@ -34,7 +34,7 @@ namespace boost { namespace property_tree
         {
         }
 
-        ~file_parser_error() throw()
+        ~file_parser_error() throw() BOOST_OVERRIDE
             // gcc 3.4.2 complains about lack of throw specifier on compiler
             // generated dtor
         {
diff --git a/include/boost/property_tree/detail/rapidxml.hpp b/include/boost/property_tree/detail/rapidxml.hpp
index 9e3d76a..d305ca0 100644
--- a/include/boost/property_tree/detail/rapidxml.hpp
+++ b/include/boost/property_tree/detail/rapidxml.hpp
@@ -13,7 +13,7 @@
 //! \file rapidxml.hpp This file contains rapidxml parser and DOM implementation
 
 #include <boost/assert.hpp>
-#include <cstdlib>      // For std::size_t
+#include <cstddef>      // For std::size_t
 #include <new>          // For placement new
 
 // On MSVC, disable "conditional expression is constant" warning (level 4). 
@@ -58,7 +58,7 @@ namespace boost { namespace property_tree { namespace detail {namespace rapidxml
 
         //! Gets human readable description of error.
         //! \return Pointer to null terminated description of the error.
-        virtual const char *what() const throw()
+        const char *what() const throw() BOOST_OVERRIDE
         {
             return m_what;
         }
@@ -138,7 +138,7 @@ namespace boost { namespace property_tree { namespace detail {namespace rapidxml
 
     //! Parse flag instructing the parser to not use text of first data node as a value of parent element.
     //! Can be combined with other flags by use of | operator.
-    //! Note that child data nodes of element node take precendence over its value when printing. 
+    //! Note that child data nodes of element node take precedence over its value when printing.
     //! That is, if element has one or more child data nodes <em>and</em> a value, the value will be ignored.
     //! Use rapidxml::parse_no_data_nodes flag to prevent creation of data nodes if you want to manipulate data using values of elements.
     //! <br><br>
@@ -334,7 +334,7 @@ namespace boost { namespace property_tree { namespace detail {namespace rapidxml
     //! you are encouraged to use memory_pool of relevant xml_document to allocate the memory. 
     //! Not only is this faster than allocating them by using <code>new</code> operator, 
     //! but also their lifetime will be tied to the lifetime of document, 
-    //! possibly simplyfing memory management. 
+    //! possibly simplifying memory management.
     //! <br><br>
     //! Call allocate_node() or allocate_attribute() functions to obtain new nodes or attributes from the pool. 
     //! You can also call allocate_string() function to allocate strings.
@@ -391,7 +391,7 @@ namespace boost { namespace property_tree { namespace detail {namespace rapidxml
         }
 
         //! Allocates a new node from the pool, and optionally assigns name and value to it. 
-        //! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.
+        //! If the allocation request cannot be accommodated, this function will throw <code>std::bad_alloc</code>.
         //! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function
         //! will call rapidxml::parse_error_handler() function.
         //! \param type Type of node to create.
@@ -424,7 +424,7 @@ namespace boost { namespace property_tree { namespace detail {namespace rapidxml
         }
 
         //! Allocates a new attribute from the pool, and optionally assigns name and value to it.
-        //! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.
+        //! If the allocation request cannot be accommodated, this function will throw <code>std::bad_alloc</code>.
         //! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function
         //! will call rapidxml::parse_error_handler() function.
         //! \param name Name to assign to the attribute, or 0 to assign no name.
@@ -455,7 +455,7 @@ namespace boost { namespace property_tree { namespace detail {namespace rapidxml
         }
 
         //! Allocates a char array of given size from the pool, and optionally copies a given string to it.
-        //! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.
+        //! If the allocation request cannot be accommodated, this function will throw <code>std::bad_alloc</code>.
         //! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function
         //! will call rapidxml::parse_error_handler() function.
         //! \param source String to initialize the allocated memory with, or 0 to not initialize it.
@@ -694,7 +694,7 @@ namespace boost { namespace property_tree { namespace detail {namespace rapidxml
         //! <br><br>
         //! Note that node does not own its name or value, it only stores a pointer to it. 
         //! It will not delete or otherwise free the pointer on destruction.
-        //! It is reponsibility of the user to properly manage lifetime of the string.
+        //! It is responsibility of the user to properly manage lifetime of the string.
         //! The easiest way to achieve it is to use memory_pool of the document to allocate the string -
         //! on destruction of the document the string will be automatically freed.
         //! <br><br>
@@ -721,7 +721,7 @@ namespace boost { namespace property_tree { namespace detail {namespace rapidxml
         //! <br><br>
         //! Note that node does not own its name or value, it only stores a pointer to it. 
         //! It will not delete or otherwise free the pointer on destruction.
-        //! It is reponsibility of the user to properly manage lifetime of the string.
+        //! It is responsibility of the user to properly manage lifetime of the string.
         //! The easiest way to achieve it is to use memory_pool of the document to allocate the string -
         //! on destruction of the document the string will be automatically freed.
         //! <br><br>
@@ -730,7 +730,7 @@ namespace boost { namespace property_tree { namespace detail {namespace rapidxml
         //! <br><br>
         //! If an element has a child node of type node_data, it will take precedence over element value when printing.
         //! If you want to manipulate data of elements using values, use parser flag rapidxml::parse_no_data_nodes to prevent creation of data nodes by the parser.
-        //! \param val value of node to set. Does not have to be zero terminated.
+        //! \param val Value of node to set. Does not have to be zero terminated.
         //! \param size Size of value, in characters. This does not include zero terminator, if one is present.
         void value(const Ch *val, std::size_t size)
         {
@@ -740,7 +740,7 @@ namespace boost { namespace property_tree { namespace detail {namespace rapidxml
 
         //! Sets value of node to a zero-terminated string.
         //! See also \ref ownership_of_strings and xml_node::value(const Ch *, std::size_t).
-        //! \param val Vame of node to set. Must be zero terminated.
+        //! \param val Name of node to set. Must be zero terminated.
         void value(const Ch *val)
         {
             this->value(val, internal::measure(val));
@@ -1311,7 +1311,7 @@ namespace boost { namespace property_tree { namespace detail {namespace rapidxml
     
         // Note that some of the pointers below have UNDEFINED values if certain other pointers are 0.
         // This is required for maximum performance, as it allows the parser to omit initialization of 
-        // unneded/redundant values.
+        // unneeded/redundant values.
         //
         // The rules are as follows:
         // 1. first_node and first_attribute contain valid pointers, or 0 if node has no children/attributes respectively
@@ -1374,7 +1374,7 @@ namespace boost { namespace property_tree { namespace detail {namespace rapidxml
             parse_bom<Flags>(text);
             
             // Parse children
-            while (1)
+            while (true)
             {
                 // Skip whitespace before node
                 skip<whitespace_pred, Flags>(text);
@@ -1636,7 +1636,7 @@ namespace boost { namespace property_tree { namespace detail {namespace rapidxml
                             {
                                 unsigned long code = 0;
                                 src += 3;   // Skip &#x
-                                while (1)
+                                while (true)
                                 {
                                     unsigned char digit = internal::lookup_tables<0>::lookup_digits[static_cast<unsigned char>(*src)];
                                     if (digit == 0xFF)
@@ -1650,7 +1650,7 @@ namespace boost { namespace property_tree { namespace detail {namespace rapidxml
                             {
                                 unsigned long code = 0;
                                 src += 2;   // Skip &#
-                                while (1)
+                                while (true)
                                 {
                                     unsigned char digit = internal::lookup_tables<0>::lookup_digits[static_cast<unsigned char>(*src)];
                                     if (digit == 0xFF)
@@ -2165,7 +2165,7 @@ namespace boost { namespace property_tree { namespace detail {namespace rapidxml
         void parse_node_contents(Ch *&text, xml_node<Ch> *node)
         {
             // For all children and text
-            while (1)
+            while (true)
             {
                 // Skip whitespace between > and node contents
                 Ch *contents_start = text;      // Store start of node contents before whitespace is skipped
@@ -2395,7 +2395,7 @@ namespace boost { namespace property_tree { namespace detail {namespace rapidxml
              1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1   // F
         };
 
-        // Text (i.e. PCDATA) that does not require processing when ws normalizationis is enabled
+        // Text (i.e. PCDATA) that does not require processing when ws normalizations is enabled
         // (anything but < \0 & space \n \r \t)
         template<int Dummy>
         const unsigned char lookup_tables<Dummy>::lookup_text_pure_with_ws[256] = 
diff --git a/include/boost/property_tree/exceptions.hpp b/include/boost/property_tree/exceptions.hpp
index b35b27f..ab4a951 100644
--- a/include/boost/property_tree/exceptions.hpp
+++ b/include/boost/property_tree/exceptions.hpp
@@ -15,8 +15,8 @@
 #include <boost/property_tree/ptree_fwd.hpp>
 
 #include <boost/any.hpp>
-#include <string>
 #include <stdexcept>
+#include <string>
 
 namespace boost { namespace property_tree
 {
@@ -31,7 +31,7 @@ namespace boost { namespace property_tree
         /// @param what The message to associate with this error.
         ptree_error(const std::string &what);
 
-        ~ptree_error() throw();
+        ~ptree_error() throw() BOOST_OVERRIDE;
     };
 
 
@@ -48,7 +48,7 @@ namespace boost { namespace property_tree
         template<class T> ptree_bad_data(const std::string &what,
                                          const T &data);
 
-        ~ptree_bad_data() throw();
+        ~ptree_bad_data() throw() BOOST_OVERRIDE;
 
         /// Retrieve the data associated with this error. This is the source
         /// value that failed to be translated. You need to explicitly
@@ -70,7 +70,7 @@ namespace boost { namespace property_tree
         template<class T> ptree_bad_path(const std::string &what,
                                          const T &path);
 
-        ~ptree_bad_path() throw();
+        ~ptree_bad_path() throw() BOOST_OVERRIDE;
 
         /// Retrieve the invalid path. You need to explicitly specify the
         /// type of path.

From 0c3b65e243ff83bc1635170263907e707b8329a0 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@gmail.com>
Date: Mon, 8 Mar 2021 23:05:30 +0200
Subject: [PATCH 05/14] Fix MSVC test failure in test_property_tree

---
 test/test_property_tree.hpp | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/test/test_property_tree.hpp b/test/test_property_tree.hpp
index 4216945..3247373 100644
--- a/test/test_property_tree.hpp
+++ b/test/test_property_tree.hpp
@@ -1204,11 +1204,19 @@ void test_serialization(PTREE *)
     // Test XML archives
     {
         std::stringstream stream;
-        boost::archive::xml_oarchive oa(stream);
-        oa & boost::serialization::make_nvp("pt", pt1);
-        boost::archive::xml_iarchive ia(stream);
+
+        {
+            boost::archive::xml_oarchive oa(stream);
+            oa & boost::serialization::make_nvp("pt", pt1);
+        }
+
         PTREE pt2;
-        ia & boost::serialization::make_nvp("pt", pt2);
+
+        {
+            boost::archive::xml_iarchive ia(stream);
+            ia & boost::serialization::make_nvp("pt", pt2);
+        }
+
         BOOST_CHECK(pt1 == pt2);
     }
 

From 74a9a09367e4d743c609baed044bd4938544436d Mon Sep 17 00:00:00 2001
From: Richard Hodges <hodges.r@gmail.com>
Date: Wed, 3 Mar 2021 19:46:28 +0100
Subject: [PATCH 06/14] Add GitHub Actions CI

---
 .github/workflows/ci.yml | 205 +++++++++++++++++++++++++++++++++++++++
 CMakeLists.txt           | 151 ++++++++++++++++++++++++++++
 cmake/config.cmake.in    |   6 ++
 examples/CMakeLists.txt  |  57 +++++++++++
 test/CMakeLists.txt      |  72 ++++++++++++++
 5 files changed, 491 insertions(+)
 create mode 100644 .github/workflows/ci.yml
 create mode 100644 CMakeLists.txt
 create mode 100644 cmake/config.cmake.in
 create mode 100644 examples/CMakeLists.txt
 create mode 100644 test/CMakeLists.txt

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..8788b1b
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,205 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+      - develop
+      - feature/**
+
+env:
+  UBSAN_OPTIONS: print_stacktrace=1
+
+jobs:
+  posix:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - toolset: gcc-4.7
+            cxxstd: "03,11"
+            os: ubuntu-16.04
+            install: g++-4.7
+          - toolset: gcc-4.8
+            cxxstd: "03,11"
+            os: ubuntu-16.04
+            install: g++-4.8
+          - toolset: gcc-4.9
+            cxxstd: "03,11"
+            os: ubuntu-16.04
+            install: g++-4.9
+          - toolset: gcc-5
+            cxxstd: "03,11,14,1z"
+            os: ubuntu-16.04
+          - toolset: gcc-6
+            cxxstd: "03,11,14,1z"
+            os: ubuntu-16.04
+            install: g++-6
+          - toolset: gcc-7
+            cxxstd: "03,11,14,17"
+            os: ubuntu-18.04
+          - toolset: gcc-8
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-18.04
+          - toolset: gcc-9
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-18.04
+          - toolset: gcc-10
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-18.04
+          - toolset: clang
+            compiler: clang++-3.5
+            cxxstd: "03,11,14"
+            os: ubuntu-16.04
+            install: clang-3.5
+          - toolset: clang
+            compiler: clang++-3.6
+            cxxstd: "03,11,14"
+            os: ubuntu-16.04
+            install: clang-3.6
+          - toolset: clang
+            compiler: clang++-3.7
+            cxxstd: "03,11,14"
+            os: ubuntu-16.04
+            install: clang-3.7
+          - toolset: clang
+            compiler: clang++-3.8
+            cxxstd: "03,11,14"
+            os: ubuntu-16.04
+            install: clang-3.8
+          - toolset: clang
+            compiler: clang++-3.9
+            cxxstd: "03,11,14"
+            os: ubuntu-16.04
+            install: clang-3.9
+          - toolset: clang
+            compiler: clang++-4.0
+            cxxstd: "03,11,14"
+            os: ubuntu-16.04
+            install: clang-4.0
+          - toolset: clang
+            compiler: clang++-5.0
+            cxxstd: "03,11,14,1z"
+            os: ubuntu-16.04
+            install: clang-5.0
+          - toolset: clang
+            compiler: clang++-6.0
+            cxxstd: "03,11,14,17"
+            os: ubuntu-18.04
+          - toolset: clang
+            compiler: clang++-7
+            cxxstd: "03,11,14,17"
+            os: ubuntu-18.04
+            install: clang-7
+          - toolset: clang
+            compiler: clang++-8
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+          - toolset: clang
+            compiler: clang++-9
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+          - toolset: clang
+            compiler: clang++-10
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-20.04
+          - toolset: clang
+            cxxstd: "03,11,14,17,2a"
+            os: macos-10.15
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          sudo ls -al /usr/sbin/l*
+          sudo locale-gen fr_FR
+          sudo locale-gen en_GB
+          sudo locale -a
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+          ./bootstrap.sh
+          ./b2 -d0 headers
+
+      - name: Create user-config.jam
+        if: matrix.compiler
+        run: |
+          echo "using ${{matrix.toolset}} : : ${{matrix.compiler}} ;" > ~/user-config.jam
+
+      - name: Run tests
+        run: |
+          cd ../boost-root
+          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} variant=debug,release
+
+  windows:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - toolset: msvc-14.1
+            cxxstd: "14,17,latest"
+            addrmd: 32,64
+            os: windows-2016
+          - toolset: msvc-14.2
+            cxxstd: "14,17,latest"
+            addrmd: 32,64
+            os: windows-2019
+          - toolset: gcc
+            cxxstd: "03,11,14,17,2a"
+            addrmd: 64
+            os: windows-2019
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+          cmd /c bootstrap
+          b2 -d0 headers
+
+      - name: Run tests
+        shell: cmd
+        run: |
+          cd ../boost-root
+          sudo b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..e9322e1
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,151 @@
+#
+# Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)
+# Copyright (c) 2021 Richard Hodges (hodges.r@gmail.com)
+#
+# Distributed under the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#
+# Official repository: https://github.com/boostorg/json
+#
+
+cmake_minimum_required(VERSION 3.5...3.19)
+
+set(BOOST_PROPERTY_TREE_VERSION 100)
+if(BOOST_SUPERPROJECT_VERSION)
+    set(BOOST_PROPERTY_TREE_VERSION ${BOOST_SUPERPROJECT_VERSION})
+endif()
+
+project(boost_property_tree VERSION "${BOOST_PROPERTY_TREE_VERSION}" LANGUAGES CXX)
+
+option(BOOST_PROPERTY_TREE_BUILD_TESTS "Build boost::property_tree tests" ON)
+option(BOOST_PROPERTY_TREE_BUILD_EXAMPLES "Build boost::property_tree examples" ON)
+
+file(GLOB_RECURSE BOOST_PROPERTY_TREE_HEADERS $<$<VERSION_GREATER_EQUAL:${CMAKE_VERSION},3.12>:CONFIGURE_DEPENDS>
+    include/boost/*.hpp
+    include/boost/*.ipp
+    include/boost/*.natvis
+)
+
+set(BOOST_PROPERTY_TREE_SOURCES
+)
+
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+
+source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR}/include/boost PREFIX "" FILES ${BOOST_PROPERTY_TREE_HEADERS})
+source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR}/src PREFIX "" FILES ${BOOST_PROPERTY_TREE_SOURCES})
+
+# TODO: For Boost superproject, do we want to support header-only mode?
+#       Then, this needs to read `add_library(boost_json INTERFACE)`
+#       and related settings need to be INTERFACE-ed as well.
+add_library(boost_property_tree INTERFACE)
+#target_sources(boost_property_tree INTERFACE ${BOOST_PROPERTY_TREE_HEADERS} ${BOOST_PROPERTY_TREE_SOURCES})
+add_library(Boost::property_tree ALIAS boost_property_tree)
+
+#target_compile_features(boost_property_tree PUBLIC cxx_constexpr)
+
+# TODO: For Boost superproject, this may need to be INTERFACE setting.
+include(GNUInstallDirs)
+if(BOOST_SUPERPROJECT_VERSION)
+    target_include_directories(boost_property_tree INTERFACE include)
+else()
+    target_include_directories(boost_property_tree
+        INTERFACE
+            "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
+            "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+    )
+endif()
+
+if(BOOST_SUPERPROJECT_VERSION)
+    #
+    # Building as part of Boost superproject tree, with Boost as dependency.
+    #
+    target_link_libraries(boost_property_tree
+        PUBLIC
+            Boost::boost
+            Boost::assert
+            Boost::config
+            Boost::container
+            Boost::exception
+            Boost::system
+            Boost::throw_exception
+            Boost::utility
+    )
+
+elseif(BOOST_PROPERTY_TREE_IN_BOOST_TREE)
+    #
+    # Building inside Boost tree, out of Boost superproject tree, with Boost as dependency.
+    # e.g. on Travis or other CI, or when producing Visual Studio Solution and Projects.
+    #
+    get_filename_component(BOOST_ROOT ../.. ABSOLUTE)
+    set(BOOST_INCLUDEDIR ${BOOST_ROOT})
+    set(BOOST_LIBRARYDIR ${BOOST_ROOT}/stage/lib)
+    find_package(Boost COMPONENTS serialization unit_test_framework REQUIRED)
+    link_libraries(Boost::serialization)
+
+
+    target_include_directories(boost_property_tree INTERFACE ${BOOST_ROOT})
+    target_link_directories(boost_property_tree INTERFACE ${BOOST_ROOT}/stage/lib)
+
+else()
+    #
+    # Building out of Boost tree, out of Boost superproject tree, with Boost as dependency.
+    # e.g. for packaging or added with add_subdirectory.
+    #
+    find_package(Boost REQUIRED
+            #COMPONENTS container system
+            )
+    target_link_libraries(boost_property_tree
+        INTERFACE
+            Boost::boost
+    )
+endif()
+
+if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND NOT BOOST_PROPERTY_TREE_IN_BOOST_TREE)
+    set_target_properties(boost_property_tree PROPERTIES EXPORT_NAME property_tree)
+    install(TARGETS boost_property_tree
+        EXPORT boost_property_tree_targets
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    )
+
+    install(EXPORT boost_property_tree_targets
+        FILE boost_property_tree-targets.cmake
+        NAMESPACE Boost::
+        DESTINATION lib/cmake/boost_property_tree
+    )
+
+    include(CMakePackageConfigHelpers)
+
+    configure_package_config_file(cmake/config.cmake.in
+        ${CMAKE_CURRENT_BINARY_DIR}/boost_property_tree-config.cmake
+        INSTALL_DESTINATION lib/cmake/boost_property_tree
+    )
+
+    write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/boost_property_tree-config-version.cmake
+        VERSION ${PROJECT_VERSION} COMPATIBILITY SameMajorVersion
+    )
+
+    install(FILES
+        ${CMAKE_CURRENT_BINARY_DIR}/boost_property_tree-config.cmake
+        ${CMAKE_CURRENT_BINARY_DIR}/boost_property_tree-config-version.cmake
+        DESTINATION lib/cmake/boost_property_tree
+    )
+
+    install(DIRECTORY include/ DESTINATION include)
+endif()
+
+if(BOOST_PROPERTY_TREE_BUILD_TESTS)
+    include(CTest)
+    if(BUILD_TESTING)
+        add_subdirectory(test)
+    endif()
+endif()
+
+if(BOOST_PROPERTY_TREE_BUILD_EXAMPLES)
+    if (BOOST_SUPERPROJECT_VERSION)
+        message(STATUS "[property_tree] superproject build - skipping examples")
+    else()
+        add_subdirectory(examples)
+    endif()
+endif()
diff --git a/cmake/config.cmake.in b/cmake/config.cmake.in
new file mode 100644
index 0000000..fdf3dec
--- /dev/null
+++ b/cmake/config.cmake.in
@@ -0,0 +1,6 @@
+@PACKAGE_INIT@
+
+include(CMakeFindDependencyMacro)
+find_dependency(Boost REQUIRED ) #COMPONENTS container system)
+
+include("${CMAKE_CURRENT_LIST_DIR}/boost_property_tree-targets.cmake")
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
new file mode 100644
index 0000000..b77bd64
--- /dev/null
+++ b/examples/CMakeLists.txt
@@ -0,0 +1,57 @@
+#
+# Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)
+# Copyright (c) 2021 Richard Hodges (hodges.r@gmail.com)
+#
+# Distributed under the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#
+# Official repository: https://github.com/boostorg/json
+#
+
+source_group("test" FILES
+    custom_data_type.cpp
+    debug_settings.cpp
+    empty_ptree_trick.cpp
+    info_grammar_spirit.cpp
+    speed_test.cpp
+)
+
+#
+
+add_executable(custom_data_type
+    custom_data_type.cpp
+)
+set_property(TARGET custom_data_type PROPERTY FOLDER "example")
+target_link_libraries(custom_data_type PRIVATE Boost::property_tree)
+
+#
+
+add_executable(debug_settings
+    debug_settings.cpp
+)
+set_property(TARGET debug_settings PROPERTY FOLDER "example")
+target_link_libraries(debug_settings PRIVATE Boost::property_tree)
+
+#
+
+add_executable(empty_ptree_trick
+    empty_ptree_trick.cpp
+)
+set_property(TARGET empty_ptree_trick PROPERTY FOLDER "example")
+target_link_libraries(empty_ptree_trick PRIVATE Boost::property_tree)
+
+#
+
+add_executable(info_grammar_spirit
+    info_grammar_spirit.cpp
+)
+set_property(TARGET info_grammar_spirit PROPERTY FOLDER "example")
+target_link_libraries(info_grammar_spirit PRIVATE Boost::property_tree)
+
+#
+
+add_executable(speed_test
+    speed_test.cpp
+)
+set_property(TARGET speed_test PROPERTY FOLDER "example")
+target_link_libraries(speed_test PRIVATE Boost::property_tree)
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
new file mode 100644
index 0000000..072f354
--- /dev/null
+++ b/test/CMakeLists.txt
@@ -0,0 +1,72 @@
+#
+# Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)
+# Copyright (c) 2021 Richard Hodges (hodges.r@gmail.com)
+#
+# Distributed under the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#
+# Official repository: https://github.com/boostorg/json
+#
+
+file(GLOB_RECURSE BOOST_PROPERTY_TREE_TESTS_FILES CONFIGURE_DEPENDS Jamfile *.cpp *.hpp)
+list(FILTER BOOST_PROPERTY_TREE_TESTS_FILES EXCLUDE REGEX "^${CMAKE_CURRENT_SOURCE_DIR}/cmake_install_test/.*$")
+
+source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} PREFIX "" FILES ${BOOST_PROPERTY_TREE_TESTS_FILES})
+
+add_executable(test-multi test_multi_module1.cpp test_multi_module2.cpp)
+target_include_directories(test-multi PRIVATE .)
+target_link_libraries(test-multi PRIVATE Boost::property_tree Boost::serialization Boost::unit_test_framework)
+add_test(NAME property_tree-test-multi COMMAND test-multi)
+
+#[[
+add_executable(tests ${BOOST_PROPERTY_TREE_TESTS_FILES})
+target_include_directories(tests PRIVATE .)
+target_link_libraries(tests PRIVATE Boost::property_tree Boost::serialization Boost::unit_test_framework)
+add_test(NAME property_tree-tests COMMAND tests)
+]]
+
+#[[
+source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} PREFIX "" FILES limits.cpp main.cpp)
+source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR}/../src PREFIX "" FILES ../src/src.cpp)
+add_executable(limits limits.cpp main.cpp ../src/src.cpp Jamfile)
+
+target_compile_features(limits PUBLIC cxx_constexpr)
+
+target_include_directories(limits PRIVATE ../include .)
+target_compile_definitions(limits PRIVATE
+    BOOST_PROPERTY_TREE_MAX_STRING_SIZE=1000
+    BOOST_PROPERTY_TREE_MAX_STRUCTURED_SIZE=20
+    BOOST_PROPERTY_TREE_STACK_BUFFER_SIZE=256
+    BOOST_PROPERTY_TREE_NO_LIB=1
+)
+]]
+
+if(BOOST_SUPERPROJECT_VERSION)
+#[[
+    target_link_libraries(limits
+        PRIVATE
+            Boost::align
+            Boost::assert
+            Boost::config
+            Boost::container
+            Boost::exception
+            Boost::system
+            Boost::throw_exception
+            Boost::utility
+    )
+]]
+elseif(BOOST_PROPERTY_TREE_IN_BOOST_TREE)
+#[[
+    target_include_directories(limits PRIVATE ${BOOST_ROOT})
+    target_link_directories(limits PRIVATE ${BOOST_ROOT}/stage/lib)
+]]
+else()
+#[[
+    target_link_libraries(limits
+        PRIVATE
+            Boost::system
+            Boost::container
+    )
+]]
+endif()
+

From 06b9c5c07df1c23b41e77a7a90af85fd38f4d120 Mon Sep 17 00:00:00 2001
From: Richard Hodges <hodges.r@gmail.com>
Date: Fri, 5 Mar 2021 18:08:33 +0100
Subject: [PATCH 07/14] add drone CI

---
 .drone.star                    |  43 ++++++++++++
 .drone/drone.sh                | 120 +++++++++++++++++++++++++++++++++
 .github/workflows/ci.yml       |   2 +-
 examples/empty_ptree_trick.cpp |   8 ++-
 4 files changed, 169 insertions(+), 4 deletions(-)
 create mode 100644 .drone.star
 create mode 100755 .drone/drone.sh

diff --git a/.drone.star b/.drone.star
new file mode 100644
index 0000000..21b4bfb
--- /dev/null
+++ b/.drone.star
@@ -0,0 +1,43 @@
+# Use, modification, and distribution are
+# subject to the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE.txt)
+#
+# Copyright Rene Rivera 2020.
+
+# For Drone CI we use the Starlark scripting language to reduce duplication.
+# As the yaml syntax for Drone CI is rather limited.
+#
+#
+
+globalenv={'B2_CI_VERSION': '1', 'B2_VARIANT': 'release'}
+linuxglobalimage="cppalliance/droneubuntu1604:1"
+windowsglobalimage="cppalliance/dronevs2019"
+
+def main(ctx):
+  return [
+  linux_cxx("COMMENT=codecov.io B2_CXXSTD=03,11 B2_TOOLSET Job 0", "g++-8", packages="g++-8 locales", buildtype="fc4716b68c-0fcaf592f9", buildscript="drone", image=linuxglobalimage, environment={'COMMENT': 'codecov.io', 'B2_CXXSTD': '03,11', 'B2_TOOLSET': 'gcc-8', 'B2_DEFINES': 'BOOST_NO_STRESS_TEST=1', 'DRONE_JOB_UUID': 'b6589fc6ab'}, globalenv=globalenv),
+  linux_cxx("COMMENT=asan B2_VARIANT=debug B2_TOOLSET=gcc- Job 1", "g++-8", packages="g++-8 locales", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'COMMENT': 'asan', 'B2_VARIANT': 'debug', 'B2_TOOLSET': 'gcc-8', 'B2_CXXSTD': '03,11,14', 'B2_ASAN': '1', 'B2_DEFINES': 'BOOST_NO_STRESS_TEST=1', 'DRONE_EXTRA_PRIVILEGED': 'True', 'DRONE_JOB_UUID': '356a192b79'}, globalenv=globalenv, privileged=True),
+  linux_cxx("COMMENT=tsan B2_VARIANT=debug B2_TOOLSET=gcc- Job 2", "g++-8", packages="g++-8 locales", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'COMMENT': 'tsan', 'B2_VARIANT': 'debug', 'B2_TOOLSET': 'gcc-8', 'B2_CXXSTD': '03,11,14', 'B2_TSAN': '1', 'B2_DEFINES': 'BOOST_NO_STRESS_TEST=1', 'DRONE_JOB_UUID': 'da4b9237ba'}, globalenv=globalenv),
+  linux_cxx("COMMENT=ubsan B2_VARIANT=debug B2_TOOLSET=gcc Job 3", "g++-8", packages="g++-8 locales", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'COMMENT': 'ubsan', 'B2_VARIANT': 'debug', 'B2_TOOLSET': 'gcc-8', 'B2_CXXSTD': '03,11,14', 'B2_UBSAN': '1', 'B2_DEFINES': 'BOOST_NO_STRESS_TEST=1', 'B2_LINKFLAGS': '-fuse-ld=gold', 'DRONE_JOB_UUID': '77de68daec'}, globalenv=globalenv),
+  linux_cxx("COMMENT=valgrind B2_TOOLSET=clang-6.0 B2_CXXS Job 4", "clang++-6.0", packages="clang-6.0 libc6-dbg libc++-dev libstdc++-8-dev locales", llvm_os="xenial", llvm_ver="6.0", buildtype="fc4716b68c-db180b7bd2", buildscript="drone", image=linuxglobalimage, environment={'COMMENT': 'valgrind', 'B2_TOOLSET': 'clang-6.0', 'B2_CXXSTD': '03,11,14', 'B2_DEFINES': 'BOOST_NO_STRESS_TEST=1', 'B2_VARIANT': 'debug', 'B2_TESTFLAGS': 'testing.launcher=valgrind', 'VALGRIND_OPTS': '--error-exitcode=1', 'DRONE_JOB_UUID': '1b64538924'}, globalenv=globalenv),
+  linux_cxx("B2_TOOLSET=gcc-4.8 B2_CXXSTD=03,11 Job 5", "g++-4.8", packages="g++-4.8 locales", buildtype="boost", buildscript="drone", image="cppalliance/droneubuntu1404:1", environment={'B2_TOOLSET': 'gcc-4.8', 'B2_CXXSTD': '03,11', 'DRONE_JOB_UUID': 'ac3478d69a'}, globalenv=globalenv),
+  linux_cxx("B2_TOOLSET=gcc-4.9 B2_CXXSTD=03,11 Job 6", "g++-4.9", packages="g++-4.9 locales", buildtype="boost", buildscript="drone", image="cppalliance/droneubuntu1404:1", environment={'B2_TOOLSET': 'gcc-4.9', 'B2_CXXSTD': '03,11', 'DRONE_JOB_UUID': 'c1dfd96eea'}, globalenv=globalenv),
+  linux_cxx("B2_TOOLSET=gcc-5 B2_CXXSTD=03,11 Job 7", "g++-5", packages="g++-5 locales", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'gcc-5', 'B2_CXXSTD': '03,11', 'DRONE_JOB_UUID': '902ba3cda1'}, globalenv=globalenv),
+  linux_cxx("B2_TOOLSET=gcc-6 B2_CXXSTD=11,14 Job 8", "g++-6", packages="g++-6 locales", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'gcc-6', 'B2_CXXSTD': '11,14', 'DRONE_JOB_UUID': 'fe5dbbcea5'}, globalenv=globalenv),
+  linux_cxx("B2_TOOLSET=gcc-7 B2_CXXSTD=14,17 Job 9", "g++-7", packages="g++-7 locales", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'gcc-7', 'B2_CXXSTD': '14,17', 'DRONE_JOB_UUID': '0ade7c2cf9'}, globalenv=globalenv),
+  linux_cxx("B2_TOOLSET=gcc-8 B2_CXXSTD=17,2a Job 10", "g++-8", packages="g++-8 locales", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'gcc-8', 'B2_CXXSTD': '17,2a', 'DRONE_JOB_UUID': 'b1d5781111'}, globalenv=globalenv),
+  linux_cxx("B2_TOOLSET=gcc-9 B2_CXXSTD=17,2a Job 11", "g++-9", packages="g++-9 locales", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'gcc-9', 'B2_CXXSTD': '17,2a', 'DRONE_JOB_UUID': '17ba079149'}, globalenv=globalenv),
+  linux_cxx("B2_TOOLSET=clang-3.8 B2_CXXSTD=03,11 Job 12", "clang++-3.8 locales", packages="clang-3.8 locales", buildtype="boost", buildscript="drone", image="cppalliance/droneubuntu1404:1", environment={'B2_TOOLSET': 'clang-3.8', 'B2_CXXSTD': '03,11', 'DRONE_JOB_UUID': '7b52009b64'}, globalenv=globalenv),
+  linux_cxx("B2_TOOLSET=clang-4.0 B2_CXXSTD=11,14 Job 13", "clang++-4.0 locales", packages="clang-4.0 libstdc++-6-dev locales", llvm_os="xenial", llvm_ver="4.0", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'clang-4.0', 'B2_CXXSTD': '11,14', 'DRONE_JOB_UUID': 'bd307a3ec3'}, globalenv=globalenv),
+  linux_cxx("B2_TOOLSET=clang-5.0 B2_CXXSTD=11,14 Job 14", "clang++-5.0 locales", packages="clang-5.0 libstdc++-7-dev locales", llvm_os="xenial", llvm_ver="5.0", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'clang-5.0', 'B2_CXXSTD': '11,14', 'DRONE_JOB_UUID': 'fa35e19212'}, globalenv=globalenv),
+  linux_cxx("B2_TOOLSET=clang-6.0 B2_CXXSTD=14,17 Job 15", "clang++-6.0 locales", packages="clang-6.0 libc6-dbg libc++-dev libstdc++-8-dev locales", llvm_os="xenial", llvm_ver="6.0", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'clang-6.0', 'B2_CXXSTD': '14,17', 'DRONE_JOB_UUID': 'f1abd67035'}, globalenv=globalenv),
+  linux_cxx("B2_TOOLSET=clang-7 B2_CXXSTD=17,2a Job 16", "clang++-7 locales", packages="clang-7 libc6-dbg libc++-dev libstdc++-8-dev locales", llvm_os="xenial", llvm_ver="7", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'clang-7', 'B2_CXXSTD': '17,2a', 'DRONE_JOB_UUID': '1574bddb75'}, globalenv=globalenv),
+  linux_cxx("B2_TOOLSET=clang-8 B2_CXXSTD=17,2a Job 17", "clang++-8 locales", packages="clang-8 libc6-dbg libc++-dev libstdc++-8-dev locales", llvm_os="xenial", llvm_ver="8", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'clang-8', 'B2_CXXSTD': '17,2a', 'DRONE_JOB_UUID': '0716d9708d'}, globalenv=globalenv),
+  linux_cxx("B2_TOOLSET=clang-9 B2_CXXSTD=03,11,14,17,2a Job 18", "clang++-9 locales", packages="clang-8 libc6-dbg libc++-dev libstdc++-8-dev locales", llvm_os="xenial", llvm_ver="8", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'clang-9', 'B2_CXXSTD': '03,11,14,17,2a', 'DRONE_JOB_UUID': '9e6a55b6b4'}, globalenv=globalenv),
+  linux_cxx("B2_TOOLSET=clang-6.0 B2_CXXSTD=03,11,14 B2_ST Job 19", "clang++-6.0 locales", packages="clang-6.0 libc6-dbg libc++-dev libstdc++-8-dev locales", llvm_os="xenial", llvm_ver="6.0", buildtype="boost", buildscript="drone", image=linuxglobalimage, environment={'B2_TOOLSET': 'clang-6.0', 'B2_CXXSTD': '03,11,14', 'B2_STDLIB': 'libc++', 'DRONE_JOB_UUID': 'b3f0c7f6bb'}, globalenv=globalenv),
+  osx_cxx("B2_TOOLSET=clang B2_CXXSTD=03,11,17 Job 20", "g++", packages="", buildtype="boost", buildscript="drone", environment={'B2_TOOLSET': 'clang', 'B2_CXXSTD': '03,11,17', 'DRONE_JOB_UUID': '91032ad7bb'}, globalenv=globalenv),
+  linux_cxx("COMMENT=Coverity Scan B2_TOOLSET=clang Job 21", "g++", packages="locales", buildtype="fc4716b68c-cce9827eb5", buildscript="drone", image=linuxglobalimage, environment={'COMMENT': 'Coverity Scan', 'B2_TOOLSET': 'clang', 'DRONE_JOB_UUID': '472b07b9fc'}, globalenv=globalenv),
+    ]
+
+# from https://github.com/boostorg/boost-ci
+load("@boost_ci//ci/drone/:functions.star", "linux_cxx","windows_cxx","osx_cxx","freebsd_cxx")
diff --git a/.drone/drone.sh b/.drone/drone.sh
new file mode 100755
index 0000000..4ae5d7c
--- /dev/null
+++ b/.drone/drone.sh
@@ -0,0 +1,120 @@
+#!/bin/bash
+
+# Copyright 2020 Rene Rivera, Sam Darwin
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+set -e
+export TRAVIS_BUILD_DIR=$(pwd)
+export DRONE_BUILD_DIR=$(pwd)
+export TRAVIS_BRANCH=$DRONE_BRANCH
+export TRAVIS_EVENT_TYPE=$DRONE_BUILD_EVENT
+export VCS_COMMIT_ID=$DRONE_COMMIT
+export GIT_COMMIT=$DRONE_COMMIT
+export REPO_NAME=$DRONE_REPO
+export USER=$(whoami)
+export CC=${CC:-gcc}
+export PATH=~/.local/bin:/usr/local/bin:$PATH
+
+if [[ ${TRAVIS_OS_NAME} =~ [Ll]inux ]]; then
+  echo Installing locales for ${TRAVIS_OS_NAME} ...
+  sudo /usr/sbin/locale-gen fr_FR
+  sudo /usr/sbin/locale-gen en_GB
+  sudo locale -a
+  echo ...done with locales
+fi
+
+if [ "$DRONE_JOB_BUILDTYPE" == "boost" ]; then
+
+echo '==================================> INSTALL'
+
+git clone https://github.com/boostorg/boost-ci.git boost-ci-cloned
+cp -prf boost-ci-cloned/ci .
+rm -rf boost-ci-cloned
+
+if [ "$TRAVIS_OS_NAME" == "osx" ]; then
+    unset -f cd
+fi
+
+export SELF=`basename $REPO_NAME`
+export BOOST_CI_TARGET_BRANCH="$TRAVIS_BRANCH"
+export BOOST_CI_SRC_FOLDER=$(pwd)
+
+. ./ci/common_install.sh
+
+echo '==================================> SCRIPT'
+
+$BOOST_ROOT/libs/$SELF/ci/travis/build.sh
+
+elif [ "$DRONE_JOB_BUILDTYPE" == "fc4716b68c-0fcaf592f9" ]; then
+
+echo '==================================> INSTALL'
+
+git clone https://github.com/boostorg/boost-ci.git boost-ci-cloned
+cp -prf boost-ci-cloned/ci .
+rm -rf boost-ci-cloned
+
+if [ "$TRAVIS_OS_NAME" == "osx" ]; then
+    unset -f cd
+fi
+
+export SELF=`basename $REPO_NAME`
+export BOOST_CI_TARGET_BRANCH="$TRAVIS_BRANCH"
+export BOOST_CI_SRC_FOLDER=$(pwd)
+
+. ./ci/common_install.sh
+
+echo '==================================> SCRIPT'
+
+cd $BOOST_ROOT/libs/$SELF
+ci/travis/codecov.sh
+
+elif [ "$DRONE_JOB_BUILDTYPE" == "fc4716b68c-db180b7bd2" ]; then
+
+echo '==================================> INSTALL'
+
+git clone https://github.com/boostorg/boost-ci.git boost-ci-cloned
+cp -prf boost-ci-cloned/ci .
+rm -rf boost-ci-cloned
+
+if [ "$TRAVIS_OS_NAME" == "osx" ]; then
+    unset -f cd
+fi
+
+export SELF=`basename $REPO_NAME`
+export BOOST_CI_TARGET_BRANCH="$TRAVIS_BRANCH"
+export BOOST_CI_SRC_FOLDER=$(pwd)
+
+. ./ci/common_install.sh
+
+echo '==================================> SCRIPT'
+
+cd $BOOST_ROOT/libs/$SELF
+ci/travis/valgrind.sh
+
+elif [ "$DRONE_JOB_BUILDTYPE" == "fc4716b68c-cce9827eb5" ]; then
+
+echo '==================================> INSTALL'
+
+git clone https://github.com/boostorg/boost-ci.git boost-ci-cloned
+cp -prf boost-ci-cloned/ci .
+rm -rf boost-ci-cloned
+
+if [ "$TRAVIS_OS_NAME" == "osx" ]; then
+    unset -f cd
+fi
+
+export SELF=`basename $REPO_NAME`
+export BOOST_CI_TARGET_BRANCH="$TRAVIS_BRANCH"
+export BOOST_CI_SRC_FOLDER=$(pwd)
+
+. ./ci/common_install.sh
+
+echo '==================================> SCRIPT'
+
+if  [ -n "${COVERITY_SCAN_NOTIFICATION_EMAIL}" -a \( "$TRAVIS_BRANCH" = "develop" -o "$TRAVIS_BRANCH" = "master" \) -a \( "$DRONE_BUILD_EVENT" = "push" -o "$DRONE_BUILD_EVENT" = "cron" \) ] ; then
+    cd $BOOST_ROOT/libs/$SELF
+    ci/travis/coverity.sh
+fi
+
+fi
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 8788b1b..e7e6a7e 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -202,4 +202,4 @@ jobs:
         shell: cmd
         run: |
           cd ../boost-root
-          sudo b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release
+          b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release
diff --git a/examples/empty_ptree_trick.cpp b/examples/empty_ptree_trick.cpp
index 37285b2..dd2c21a 100644
--- a/examples/empty_ptree_trick.cpp
+++ b/examples/empty_ptree_trick.cpp
@@ -16,13 +16,15 @@
 
 using namespace boost::property_tree;
 
-// Process settings using empty ptree trick. Note that it is considerably simpler 
+  static ptree dflt;
+
+    // Process settings using empty ptree trick. Note that it is considerably simpler
 // than version which does not use the "trick"
 void process_settings(const std::string &filename)
 {
     ptree pt;
-    read_info(filename, pt);    
-    const ptree &settings = pt.get_child("settings", empty_ptree<ptree>());
+    read_info(filename, pt);
+    const ptree &settings = pt.get_child("settings", dflt);
     std::cout << "\n    Processing " << filename << std::endl;
     std::cout << "        Setting 1 is " << settings.get("setting1", 0) << std::endl;
     std::cout << "        Setting 2 is " << settings.get("setting2", 0.0) << std::endl;

From 89fa8400fd14292f0595dcd52f034f17fc7e1ec1 Mon Sep 17 00:00:00 2001
From: Edward Diener <eldlistmailingz@tropicsoft.com>
Date: Thu, 21 Jan 2021 00:02:44 -0500
Subject: [PATCH 08/14] [skip ci] Add "cxxstd" json field. The "cxxstd" json
 field is being added to each Boost library's meta json information for
 libraries in order to specify the minumum C++ standard compilation level. The
 value of this field matches one of the values for 'cxxstd' in Boost.Build.
 The purpose of doing this is to provide information for the Boost website
 documentation for each library which will specify the minimum C++ standard
 compilation that an end-user must employ in order to use the particular
 library. This will aid end-users who want to know if they can successfully
 use a Boost library based on their C++ compiler's  compilation level, without
 having to search the library's documentation to find this out.

---
 meta/libraries.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/meta/libraries.json b/meta/libraries.json
index 025c043..0f5385c 100644
--- a/meta/libraries.json
+++ b/meta/libraries.json
@@ -12,5 +12,6 @@
     ],
     "maintainers": [
         "Sebastian Redl <sebastian.redl -at- getdesigned.at>"
-    ]
+    ],
+    "cxxstd": "03"
 }

From 8feb1d9072366417e71c33bdedee68ae42d66d0e Mon Sep 17 00:00:00 2001
From: Richard Hodges <hodges.r@gmail.com>
Date: Tue, 9 Mar 2021 11:10:24 +0100
Subject: [PATCH 09/14] add all tests to cmake

---
 test/CMakeLists.txt | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 072f354..7c44e69 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -13,10 +13,20 @@ list(FILTER BOOST_PROPERTY_TREE_TESTS_FILES EXCLUDE REGEX "^${CMAKE_CURRENT_SOUR
 
 source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} PREFIX "" FILES ${BOOST_PROPERTY_TREE_TESTS_FILES})
 
-add_executable(test-multi test_multi_module1.cpp test_multi_module2.cpp)
-target_include_directories(test-multi PRIVATE .)
-target_link_libraries(test-multi PRIVATE Boost::property_tree Boost::serialization Boost::unit_test_framework)
-add_test(NAME property_tree-test-multi COMMAND test-multi)
+macro(PTREE_TEST name)
+    add_executable("${name}" ${ARGN})
+    target_include_directories("${name}" PRIVATE .)
+    target_link_libraries("${name}" PRIVATE Boost::property_tree Boost::serialization Boost::unit_test_framework)
+    add_test(NAME "property_tree-${name}" COMMAND "${name}")
+endmacro()
+
+PTREE_TEST(test-multi test_multi_module1.cpp test_multi_module2.cpp)
+PTREE_TEST(test-property-tree test_property_tree.cpp test_property_tree.hpp)
+PTREE_TEST(test-info-parser test_info_parser.cpp)
+PTREE_TEST(test-json-parser test_json_parser.cpp)
+PTREE_TEST(test-json-parser2 test_json_parser2.cpp)
+PTREE_TEST(test-ini-parser test_ini_parser.cpp)
+PTREE_TEST(test-xml-parser-rapidxml test_xml_parser_rapidxml.cpp)
 
 #[[
 add_executable(tests ${BOOST_PROPERTY_TREE_TESTS_FILES})

From f701915efa443025382b1c3f5d2c99b3c925dc6a Mon Sep 17 00:00:00 2001
From: Richard Hodges <hodges.r@gmail.com>
Date: Tue, 9 Mar 2021 12:25:48 +0100
Subject: [PATCH 10/14] Update maintainer

---
 meta/libraries.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/meta/libraries.json b/meta/libraries.json
index 0f5385c..cd6f52f 100644
--- a/meta/libraries.json
+++ b/meta/libraries.json
@@ -11,7 +11,7 @@
         "Data"
     ],
     "maintainers": [
-        "Sebastian Redl <sebastian.redl -at- getdesigned.at>"
+        "Richard Hodges <hodges.r@gmail.com>"
     ],
     "cxxstd": "03"
 }

From e072fbc9d49e7b55a1d3867744e96a4d0a162dbe Mon Sep 17 00:00:00 2001
From: Richard Hodges <hodges.r@gmail.com>
Date: Tue, 9 Mar 2021 13:06:14 +0100
Subject: [PATCH 11/14] ci: remove locale building for osx

---
 .github/workflows/ci.yml | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e7e6a7e..c97bdc3 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -119,10 +119,13 @@ jobs:
 
       - name: Setup Boost
         run: |
-          sudo ls -al /usr/sbin/l*
-          sudo locale-gen fr_FR
-          sudo locale-gen en_GB
-          sudo locale -a
+          if [[ $(uname) =~ [Ll]inux ]]; then
+            echo Installing locales for ${TRAVIS_OS_NAME} ...
+            sudo /usr/sbin/locale-gen fr_FR
+            sudo /usr/sbin/locale-gen en_GB
+            sudo locale -a
+            echo ...done with locales
+          fi
           echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
           LIBRARY=${GITHUB_REPOSITORY#*/}
           echo LIBRARY: $LIBRARY

From 61aeb12ecdc531189d79bf331da6a2da1512993b Mon Sep 17 00:00:00 2001
From: Richard Hodges <hodges.r@gmail.com>
Date: Wed, 10 Mar 2021 21:23:39 +0100
Subject: [PATCH 12/14] Fix github actions CI:

- Also remove dependency on boost test framework

closes #75
---
 .github/workflows/ci.yml          |  46 +-
 CMakeLists.txt                    |   4 +-
 test/CMakeLists.txt               |   2 +-
 test/Jamfile.v2                   |   2 +-
 test/test_info_parser.cpp         |   8 +-
 test/test_ini_parser.cpp          |   8 +-
 test/test_json_parser.cpp         |  10 +-
 test/test_json_parser2.cpp        | 809 ++++++++++++++++++------------
 test/test_property_tree.cpp       |   5 +-
 test/test_property_tree.hpp       | 740 +++++++++++++--------------
 test/test_utils.hpp               |  18 +-
 test/test_xml_parser_rapidxml.cpp |   4 +-
 12 files changed, 931 insertions(+), 725 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c97bdc3..156cc4f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -154,7 +154,24 @@ jobs:
       - name: Run tests
         run: |
           cd ../boost-root
-          ./b2 -j3 libs/$LIBRARY/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} variant=debug,release
+          toolsets=$(sed 's/,/ /g' <<<"${{matrix.toolset}}")
+          standards=$(sed 's/,/ /g' <<<"${{matrix.cxxstd}}")
+          variants="debug release"
+          err=0
+          for toolset in ${toolsets} ; do
+            for standard in ${standards} ; do
+              for variant in ${variants} ; do
+                if [[ err -ne 0 ]] ; then
+                  echo "skipping: ${toolset} ${standard} ${variant}"
+                else
+                  echo "running: ${toolset} ${standard} ${variant}"
+                  ./b2 -j3 libs/$LIBRARY/test toolset=${toolset} cxxstd=${standard} variant=${variant}
+                  err=$?
+                fi
+              done
+            done
+          done
+          [[ $err -ne 0 ]] && false || true
 
   windows:
     strategy:
@@ -165,14 +182,17 @@ jobs:
             cxxstd: "14,17,latest"
             addrmd: 32,64
             os: windows-2016
+            cxxflags: ""
           - toolset: msvc-14.2
             cxxstd: "14,17,latest"
             addrmd: 32,64
             os: windows-2019
+            cxxflags: ""
           - toolset: gcc
             cxxstd: "03,11,14,17,2a"
             addrmd: 64
             os: windows-2019
+            cxxflags: "cxxflags=-Wa,-mbig-obj"
 
     runs-on: ${{matrix.os}}
 
@@ -202,7 +222,27 @@ jobs:
           b2 -d0 headers
 
       - name: Run tests
-        shell: cmd
+        shell: bash
         run: |
           cd ../boost-root
-          b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release
+          toolsets=$(sed 's/,/ /g' <<<"${{matrix.toolset}}")
+          standards=$(sed 's/,/ /g' <<<"${{matrix.cxxstd}}")
+          address_models=$(sed 's/,/ /g' <<<"${{matrix.addrmd}}")
+          variants="debug release"
+          err=0
+          for toolset in ${toolsets} ; do
+            for standard in ${standards} ; do
+              for address_model in ${address_models} ; do
+                for variant in ${variants} ; do
+                  if [[ err -ne 0 ]] ; then
+                    echo "skipping: ${toolset} ${standard} ${address_model} ${variant}"
+                  else
+                    echo "running: ${toolset} ${standard} ${address_model} ${variant}"
+                    ./b2 -j3 ${{matrix.cxxflags}} libs/$LIBRARY/test toolset=${toolset} cxxstd=${standard} address-model=${address_model} variant=${variant}
+                    err=$?
+                  fi
+                done
+              done
+            done
+          done
+          [[ $err -ne 0 ]] && false || true
diff --git a/CMakeLists.txt b/CMakeLists.txt
index e9322e1..20ead53 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -79,9 +79,7 @@ elseif(BOOST_PROPERTY_TREE_IN_BOOST_TREE)
     get_filename_component(BOOST_ROOT ../.. ABSOLUTE)
     set(BOOST_INCLUDEDIR ${BOOST_ROOT})
     set(BOOST_LIBRARYDIR ${BOOST_ROOT}/stage/lib)
-    find_package(Boost COMPONENTS serialization unit_test_framework REQUIRED)
-    link_libraries(Boost::serialization)
-
+    find_package(Boost COMPONENTS serialization REQUIRED)
 
     target_include_directories(boost_property_tree INTERFACE ${BOOST_ROOT})
     target_link_directories(boost_property_tree INTERFACE ${BOOST_ROOT}/stage/lib)
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 7c44e69..63c6bbc 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -16,7 +16,7 @@ source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} PREFIX "" FILES ${BOOST_PROPERTY_T
 macro(PTREE_TEST name)
     add_executable("${name}" ${ARGN})
     target_include_directories("${name}" PRIVATE .)
-    target_link_libraries("${name}" PRIVATE Boost::property_tree Boost::serialization Boost::unit_test_framework)
+    target_link_libraries("${name}" PRIVATE Boost::property_tree Boost::serialization)
     add_test(NAME "property_tree-${name}" COMMAND "${name}")
 endmacro()
 
diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
index af25731..c332508 100644
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -19,7 +19,7 @@ test-suite "property_tree"
    : [ run test_property_tree.cpp /boost/serialization//boost_serialization ]
      [ run test_info_parser.cpp ]
      [ run test_json_parser.cpp ]
-     [ run test_json_parser2.cpp /boost/test//boost_unit_test_framework ]
+     [ run test_json_parser2.cpp ]
      [ run test_ini_parser.cpp ]
      [ run test_xml_parser_rapidxml.cpp ]
 
diff --git a/test/test_info_parser.cpp b/test/test_info_parser.cpp
index 798f09e..4590884 100644
--- a/test/test_info_parser.cpp
+++ b/test/test_info_parser.cpp
@@ -229,14 +229,14 @@ void test_info_parser()
         Ptree pt, default_pt;
         pt.put_value(1);
         default_pt.put_value(2);
-        BOOST_CHECK(pt != default_pt);
+        BOOST_TEST(pt != default_pt);
         read_info("nonexisting file.nonexisting file", pt, default_pt);
-        BOOST_CHECK(pt == default_pt);
+        BOOST_TEST(pt == default_pt);
     }
 
 }
 
-int test_main(int argc, char *argv[])
+int main()
 {
     using namespace boost::property_tree;
     test_info_parser<ptree>();
@@ -245,5 +245,5 @@ int test_main(int argc, char *argv[])
     test_info_parser<wptree>();
     test_info_parser<wiptree>();
 #endif
-    return 0;
+    return boost::report_errors();
 }
diff --git a/test/test_ini_parser.cpp b/test/test_ini_parser.cpp
index 2edb48c..3d7a8b6 100644
--- a/test/test_ini_parser.cpp
+++ b/test/test_ini_parser.cpp
@@ -204,12 +204,12 @@ void test_other_trees()
         s.seekg(0, std::ios_base::beg);
         ptree result;
         read_ini(s, result);
-        BOOST_CHECK(result.get("section.innerkey", "bad") == "v1");
-        BOOST_CHECK(result.get("nosection", "bad") == "v2");
+        BOOST_TEST(result.get("section.innerkey", "bad") == "v1");
+        BOOST_TEST(result.get("nosection", "bad") == "v2");
     }
 }
 
-int test_main(int argc, char *argv[])
+int main()
 {
     test_ini_parser<ptree>();
     test_ini_parser<iptree>();
@@ -221,6 +221,6 @@ int test_main(int argc, char *argv[])
     test_unmappable_trees();
     test_other_trees();
  
-    return 0;
+    return boost::report_errors();
 
 }
diff --git a/test/test_json_parser.cpp b/test/test_json_parser.cpp
index 3c14d9b..6a6ddd2 100644
--- a/test/test_json_parser.cpp
+++ b/test/test_json_parser.cpp
@@ -411,24 +411,24 @@ void test_escaping_utf8()
     std::string str = "\xD0\x9C\xD0\xB0\xD0\xBC\xD0\xB0 "
       "\xD0\xBC\xD1\x8B\xD0\xBB\xD0\xB0 \xD1\x80\xD0\xB0\xD0\xBC\xD1\x83";
     // Should NOT escape UTF-8
-    BOOST_CHECK(boost::property_tree::json_parser::create_escapes(str) == str);
+    BOOST_TEST(boost::property_tree::json_parser::create_escapes(str) == str);
 }
 
 void test_escaping_wide()
 {
     // Should NOT escape characters within ASCII range.
     std::wstring str1 = L"I am wstring with ASCII";
-    BOOST_CHECK(boost::property_tree::json_parser::create_escapes(str1) == str1);
+    BOOST_TEST(boost::property_tree::json_parser::create_escapes(str1) == str1);
     // Should escape characters outside ASCII range - this is NOT utf-8
     // This is cyrillic text
     std::wstring str2 = L"\u041C\u0430\u043C\u0430 "
         L"\u043C\u044B\u043B\u0430 \u0440\u0430\u043C\u0443";
-    BOOST_CHECK(boost::property_tree::json_parser::create_escapes(str2) ==
+    BOOST_TEST(boost::property_tree::json_parser::create_escapes(str2) ==
         L"\\u041C\\u0430\\u043C\\u0430 "
         L"\\u043C\\u044B\\u043B\\u0430 \\u0440\\u0430\\u043C\\u0443");
 }
 
-int test_main(int argc, char *argv[])
+int main(int , char *[])
 {
     using namespace boost::property_tree;
     test_json_parser<ptree>();
@@ -439,5 +439,5 @@ int test_main(int argc, char *argv[])
     test_json_parser<wiptree>();
     test_escaping_wide();
 #endif
-    return 0;
+    return boost::report_errors();
 }
diff --git a/test/test_json_parser2.cpp b/test/test_json_parser2.cpp
index 248ba46..75c8abc 100644
--- a/test/test_json_parser2.cpp
+++ b/test/test_json_parser2.cpp
@@ -4,9 +4,7 @@
 #include <boost/property_tree/json_parser/detail/standard_callbacks.hpp>
 #include "prefixing_callbacks.hpp"
 
-#define BOOST_TEST_NO_MAIN
-#include <boost/test/unit_test.hpp>
-#include <boost/test/parameterized_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 #include <boost/property_tree/ptree.hpp>
 #include <boost/range/iterator_range.hpp>
@@ -14,6 +12,7 @@
 #include <cassert>
 #include <sstream>
 #include <vector>
+#include <algorithm>
 
 using namespace boost::property_tree;
 
@@ -126,105 +125,125 @@ struct prefixing_parser
 #define BOM_N "\xef\xbb\xbf"
 #define BOM_W L"\xfeff"
 
-namespace boost { namespace test_tools { namespace tt_detail {
-    template<>
-    struct print_log_value<std::wstring> {
-        void operator()(std::ostream& os, const std::wstring& s) {
-            print_log_value<const wchar_t*>()(os, s.c_str());
-        }
-    };
-}}}
-BOOST_TEST_DONT_PRINT_LOG_VALUE(ptree::iterator)
-BOOST_TEST_DONT_PRINT_LOG_VALUE(ptree::const_iterator)
-BOOST_TEST_DONT_PRINT_LOG_VALUE(wptree::iterator)
-BOOST_TEST_DONT_PRINT_LOG_VALUE(wptree::const_iterator)
-
-BOOST_AUTO_TEST_CASE(null_parse_result_is_input) {
+static void
+test_null_parse_result_is_input()
+{
     std::string parsed;
     standard_parser<char> p;
-    BOOST_REQUIRE(p.parse_null("null", parsed));
-    BOOST_CHECK_EQUAL("null", parsed);
+    BOOST_TEST(p.parse_null("null", parsed));
+    BOOST_TEST_EQ("null", parsed);
 }
 
-BOOST_AUTO_TEST_CASE(uses_traits_from_null)
+static void
+test_uses_traits_from_null()
 {
     std::string parsed;
     prefixing_parser<char> p;
-    BOOST_REQUIRE(p.parse_null("null", parsed));
-    BOOST_CHECK_EQUAL("_:null", parsed);
+    BOOST_TEST(p.parse_null("null", parsed));
+    BOOST_TEST_EQ("_:null", parsed);
 }
 
-BOOST_AUTO_TEST_CASE(null_parse_skips_bom) {
+static void
+test_null_parse_skips_bom()
+{
     std::string parsed;
     standard_parser<char> p;
-    BOOST_REQUIRE(p.parse_null(BOM_N "null", parsed));
-    BOOST_CHECK_EQUAL("null", parsed);
+    BOOST_TEST(p.parse_null(BOM_N "null", parsed));
+    BOOST_TEST_EQ("null", parsed);
 }
 
-BOOST_AUTO_TEST_CASE(null_parse_result_is_input_w) {
+static void
+test_null_parse_result_is_input_w()
+{
     std::wstring parsed;
     standard_parser<wchar_t> p;
-    BOOST_REQUIRE(p.parse_null(L"null", parsed));
-    BOOST_CHECK_EQUAL(L"null", parsed);
+    BOOST_TEST(p.parse_null(L"null", parsed));
+    BOOST_TEST(parsed == L"null");
 }
 
-BOOST_AUTO_TEST_CASE(uses_traits_from_null_w)
+static void
+test_uses_traits_from_null_w()
 {
     std::wstring parsed;
     prefixing_parser<wchar_t> p;
-    BOOST_REQUIRE(p.parse_null(L"null", parsed));
-    BOOST_CHECK_EQUAL(L"_:null", parsed);
+    BOOST_TEST(p.parse_null(L"null", parsed));
+    BOOST_TEST(parsed == L"_:null");
 }
 
-BOOST_AUTO_TEST_CASE(null_parse_skips_bom_w) {
+static void
+test_null_parse_skips_bom_w()
+{
     std::wstring parsed;
     standard_parser<wchar_t> p;
-    BOOST_REQUIRE(p.parse_null(BOM_W L"null", parsed));
-    BOOST_CHECK_EQUAL(L"null", parsed);
+    BOOST_TEST(p.parse_null(BOM_W L"null", parsed));
+    BOOST_TEST(parsed == L"null");
 }
 
-void boolean_parse_result_is_input_n(const char* param) {
-    std::string parsed;
-    standard_parser<char> p;
-    BOOST_REQUIRE(p.parse_boolean(param, parsed));
-    BOOST_CHECK_EQUAL(param, parsed);
+template<std::size_t N>
+static void
+test_boolean_parse_result_is_input_n(const std::string (&param)[N])
+{
+    for(std::size_t i = 0 ; i < N ; ++i)
+    {
+        std::string parsed;
+        standard_parser<char> p;
+        BOOST_TEST(p.parse_boolean(param[i], parsed));
+        BOOST_TEST_EQ(param[i], parsed);
+    }
 }
 
-const char* const booleans_n[] = { "true", "false" };
+const std::string
+booleans_n[] = { "true", "false" };
 
-BOOST_AUTO_TEST_CASE(uses_traits_from_boolean_n)
+static void
+test_uses_traits_from_boolean_n()
 {
     std::string parsed;
     prefixing_parser<char> p;
-    BOOST_REQUIRE(p.parse_boolean("true", parsed));
-    BOOST_CHECK_EQUAL("b:true", parsed);
+    BOOST_TEST(p.parse_boolean("true", parsed));
+    BOOST_TEST_EQ("b:true", parsed);
 }
 
-void boolean_parse_result_is_input_w(const wchar_t* param) {
-    std::wstring parsed;
-    standard_parser<wchar_t> p;
-    BOOST_REQUIRE(p.parse_boolean(param, parsed));
-    BOOST_CHECK_EQUAL(param, parsed);
+template<std::size_t N>
+static void
+test_boolean_parse_result_is_input_w(const std::wstring (&param)[N])
+{
+    for(std::size_t i = 0 ; i < N ; ++i)
+    {
+        std::wstring parsed;
+        standard_parser<wchar_t> p;
+        BOOST_TEST(p.parse_boolean(param[i], parsed));
+        BOOST_TEST(param[i] == parsed);
+    }
 }
 
-const wchar_t* const booleans_w[] = { L"true", L"false" };
+const std::wstring
+booleans_w[] = { L"true", L"false" };
 
-BOOST_AUTO_TEST_CASE(uses_traits_from_boolean_w)
+static void
+test_uses_traits_from_boolean_w()
 {
     std::wstring parsed;
     prefixing_parser<wchar_t> p;
-    BOOST_REQUIRE(p.parse_boolean(L"true", parsed));
-    BOOST_CHECK_EQUAL(L"b:true", parsed);
+    BOOST_TEST(p.parse_boolean(L"true", parsed));
+    BOOST_TEST(parsed == L"b:true");
 }
 
-void number_parse_result_is_input_n(const char* param) {
-    std::string parsed;
-    standard_parser<char> p;
-    BOOST_REQUIRE(p.parse_number(param, parsed));
-    BOOST_CHECK_EQUAL(param, parsed);
+template<std::size_t N>
+static void
+test_number_parse_result_is_input_n(std::string const (&param)[N])
+{
+    for(std::size_t i = 0 ; i < N ; ++i)
+    {
+        std::string parsed;
+        standard_parser<char> p;
+        BOOST_TEST(p.parse_number(param[i], parsed));
+        BOOST_TEST_EQ(param[i], parsed);
+    }
 }
 
-const char* const numbers_n[] = {
+std::string const
+numbers_n[] = {
     "0",
     "-0",
     "1824",
@@ -235,22 +254,29 @@ const char* const numbers_n[] = {
     "1.1e134"
 };
 
-BOOST_AUTO_TEST_CASE(uses_traits_from_number_n)
+static void
+test_uses_traits_from_number_n()
 {
     std::string parsed;
     prefixing_parser<char> p;
-    BOOST_REQUIRE(p.parse_number("12345", parsed));
-    BOOST_CHECK_EQUAL("n:12345", parsed);
+    BOOST_TEST(p.parse_number("12345", parsed));
+    BOOST_TEST_EQ("n:12345", parsed);
 }
 
-void number_parse_result_is_input_w(const wchar_t* param) {
-    std::wstring parsed;
-    standard_parser<wchar_t> p;
-    BOOST_REQUIRE(p.parse_number(param, parsed));
-    BOOST_CHECK_EQUAL(param, parsed);
+template<std::size_t N>
+static void
+test_number_parse_result_is_input_w(const std::wstring (&param)[N])
+{
+    for(std::size_t i = 0 ; i < N ; ++i)
+    {
+        std::wstring parsed;
+        standard_parser<wchar_t> p;
+        BOOST_TEST(p.parse_number(param[i], parsed));
+        BOOST_TEST(parsed == param[i]);
+    }
 }
 
-const wchar_t* const numbers_w[] = {
+std::wstring const numbers_w[] = {
     L"0",
     L"-0",
     L"1824",
@@ -261,12 +287,13 @@ const wchar_t* const numbers_w[] = {
     L"1.1e134"
 };
 
-BOOST_AUTO_TEST_CASE(uses_traits_from_number_w)
+static void
+test_uses_traits_from_number_w()
 {
     std::wstring parsed;
     prefixing_parser<wchar_t> p;
-    BOOST_REQUIRE(p.parse_number(L"12345", parsed));
-    BOOST_CHECK_EQUAL(L"n:12345", parsed);
+    BOOST_TEST(p.parse_number(L"12345", parsed));
+    BOOST_TEST(parsed == L"n:12345");
 }
 
 struct string_input_n {
@@ -274,11 +301,16 @@ struct string_input_n {
     const char* expected;
 };
 
-void string_parsed_correctly_n(string_input_n param) {
-    std::string parsed;
-    standard_parser<char> p;
-    BOOST_REQUIRE(p.parse_string(param.encoded, parsed));
-    BOOST_CHECK_EQUAL(param.expected, parsed);
+template<std::size_t N>
+void test_string_parsed_correctly_n(string_input_n const (&param)[N])
+{
+    for(std::size_t i = 0 ; i < N ; ++i)
+    {
+        std::string parsed;
+        standard_parser<char> p;
+        BOOST_TEST(p.parse_string(param[i].encoded, parsed));
+        BOOST_TEST_EQ(param[i].expected, parsed);
+    }
 }
 
 const string_input_n strings_n[] = {
@@ -297,12 +329,13 @@ const string_input_n strings_n[] = {
     {"\xef\xbb\xbf\"\"", ""} // BOM
 };
 
-BOOST_AUTO_TEST_CASE(uses_string_callbacks)
+static void
+test_uses_string_callbacks()
 {
     std::string parsed;
     prefixing_parser<char> p;
-    BOOST_REQUIRE(p.parse_string("\"a\"", parsed));
-    BOOST_CHECK_EQUAL("s:a", parsed);
+    BOOST_TEST(p.parse_string("\"a\"", parsed));
+    BOOST_TEST_EQ("s:a", parsed);
 }
 
 struct string_input_w {
@@ -310,11 +343,17 @@ struct string_input_w {
     const wchar_t* expected;
 };
 
-void string_parsed_correctly_w(string_input_w param) {
-    std::wstring parsed;
-    standard_parser<wchar_t> p;
-    BOOST_REQUIRE(p.parse_string(param.encoded, parsed));
-    BOOST_CHECK_EQUAL(param.expected, parsed);
+template<std::size_t N>
+void
+test_string_parsed_correctly_w(string_input_w const (&param)[N])
+{
+    for(std::size_t i = 0 ; i < N ; ++i)
+    {
+        std::wstring parsed;
+        standard_parser<wchar_t> p;
+        if(BOOST_TEST(p.parse_string(param[i].encoded, parsed)))
+            BOOST_TEST(param[i].expected == parsed);
+    }
 }
 
 const string_input_w strings_w[] = {
@@ -332,137 +371,165 @@ const string_input_w strings_w[] = {
     {L"\xfeff\"\"", L""} // BOM
 };
 
-BOOST_AUTO_TEST_CASE(empty_array) {
+static void 
+test_empty_array()
+{
     ptree tree;
     standard_parser<char> p;
     const char* input = " [ ]";
-    BOOST_REQUIRE(p.parse_array(input, tree));
-    BOOST_CHECK_EQUAL("", tree.data());
-    BOOST_CHECK_EQUAL(0u, tree.size());
+    BOOST_TEST(p.parse_array(input, tree));
+    BOOST_TEST_EQ("", tree.data());
+    BOOST_TEST_EQ(0u, tree.size());
 }
 
-BOOST_AUTO_TEST_CASE(array_gets_tagged) {
+static void
+test_array_gets_tagged()
+{
     wptree tree;
     prefixing_parser<wchar_t> p;
     const wchar_t* input = L" [ ]";
-    BOOST_REQUIRE(p.parse_array(input, tree));
-    BOOST_CHECK_EQUAL(L"a:", tree.data());
-    BOOST_CHECK_EQUAL(0u, tree.size());
+    BOOST_TEST(p.parse_array(input, tree));
+    BOOST_TEST(tree.data() == L"a:");
+    BOOST_TEST_EQ(0u, tree.size());
 }
 
-BOOST_AUTO_TEST_CASE(array_with_values) {
+static void
+test_array_with_values()
+{
     wptree tree;
     standard_parser<wchar_t> p;
     const wchar_t* input = L"[\n"
 L"      123, \"abc\" ,true ,\n"
 L"      null\n"
 L"  ]";
-    BOOST_REQUIRE(p.parse_array(input, tree));
-    BOOST_REQUIRE_EQUAL(4u, tree.size());
+    if(!BOOST_TEST(p.parse_array(input, tree))) 
+        return;
+    if(!BOOST_TEST_EQ(4u, tree.size()))
+        return;
     wptree::iterator it = tree.begin();
-    BOOST_CHECK_EQUAL(L"", it->first);
-    BOOST_CHECK_EQUAL(L"123", it->second.data());
+    BOOST_TEST(it->first == L"");
+    BOOST_TEST(it->second.data() == L"123");
     ++it;
-    BOOST_CHECK_EQUAL(L"", it->first);
-    BOOST_CHECK_EQUAL(L"abc", it->second.data());
+    BOOST_TEST(it->first == L"");
+    BOOST_TEST(it->second.data() == L"abc");
     ++it;
-    BOOST_CHECK_EQUAL(L"", it->first);
-    BOOST_CHECK_EQUAL(L"true", it->second.data());
+    BOOST_TEST(it->first == L"");
+    BOOST_TEST(it->second.data() == L"true");
     ++it;
-    BOOST_CHECK_EQUAL(L"", it->first);
-    BOOST_CHECK_EQUAL(L"null", it->second.data());
+    BOOST_TEST(it->first == L"");
+    BOOST_TEST(it->second.data() == L"null");
     ++it;
-    BOOST_CHECK_EQUAL(tree.end(), it);
+    BOOST_TEST(tree.end() == it);
 }
 
-BOOST_AUTO_TEST_CASE(array_values_get_tagged) {
+static void
+test_array_values_get_tagged()
+{
     ptree tree;
     prefixing_parser<char> p;
     const char* input = "[\n"
 "       123, \"abc\" ,true ,\n"
 "       null\n"
 "   ]";
-    BOOST_REQUIRE(p.parse_array(input, tree));
-    BOOST_REQUIRE_EQUAL(4u, tree.size());
-    BOOST_CHECK_EQUAL("a:", tree.data());
-    ptree::iterator it = tree.begin();
-    BOOST_CHECK_EQUAL("", it->first);
-    BOOST_CHECK_EQUAL("n:123", it->second.data());
-    ++it;
-    BOOST_CHECK_EQUAL("", it->first);
-    BOOST_CHECK_EQUAL("s:abc", it->second.data());
-    ++it;
-    BOOST_CHECK_EQUAL("", it->first);
-    BOOST_CHECK_EQUAL("b:true", it->second.data());
-    ++it;
-    BOOST_CHECK_EQUAL("", it->first);
-    BOOST_CHECK_EQUAL("_:null", it->second.data());
-    ++it;
-    BOOST_CHECK_EQUAL(tree.end(), it);
+    if(BOOST_TEST(p.parse_array(input, tree)))
+        if(BOOST_TEST_EQ(4u, tree.size()))
+        {
+            BOOST_TEST_EQ("a:", tree.data());
+            ptree::iterator it = tree.begin();
+            BOOST_TEST_EQ("", it->first);
+            BOOST_TEST_EQ("n:123", it->second.data());
+            ++it;
+            BOOST_TEST_EQ("", it->first);
+            BOOST_TEST_EQ("s:abc", it->second.data());
+            ++it;
+            BOOST_TEST_EQ("", it->first);
+            BOOST_TEST_EQ("b:true", it->second.data());
+            ++it;
+            BOOST_TEST_EQ("", it->first);
+            BOOST_TEST_EQ("_:null", it->second.data());
+            ++it;
+            BOOST_TEST(tree.end() == it);
+        }
 }
 
-BOOST_AUTO_TEST_CASE(nested_array) {
+static void
+test_nested_array()
+{
     ptree tree;
     standard_parser<char> p;
     const char* input = "[[1,2],3,[4,5]]";
-    BOOST_REQUIRE(p.parse_array(input, tree));
-    BOOST_REQUIRE_EQUAL(3u, tree.size());
+    if(!BOOST_TEST(p.parse_array(input, tree)))
+        return;
+    if(!BOOST_TEST_EQ(3u, tree.size()))
+        return;
     ptree::iterator it = tree.begin();
-    BOOST_CHECK_EQUAL("", it->first);
+    BOOST_TEST_EQ("", it->first);
     {
         ptree& sub = it->second;
-        BOOST_CHECK_EQUAL("", sub.data());
-        BOOST_REQUIRE_EQUAL(2u, sub.size());
+        BOOST_TEST_EQ("", sub.data());
+        if(!BOOST_TEST_EQ(2u, sub.size()))
+            return;
         ptree::iterator iit = sub.begin();
-        BOOST_CHECK_EQUAL("", iit->first);
-        BOOST_CHECK_EQUAL("1", iit->second.data());
+        BOOST_TEST_EQ("", iit->first);
+        BOOST_TEST_EQ("1", iit->second.data());
         ++iit;
-        BOOST_CHECK_EQUAL("", iit->first);
-        BOOST_CHECK_EQUAL("2", iit->second.data());
+        BOOST_TEST_EQ("", iit->first);
+        BOOST_TEST_EQ("2", iit->second.data());
         ++iit;
-        BOOST_CHECK_EQUAL(sub.end(), iit);
+        BOOST_TEST(sub.end() == iit);
     }
     ++it;
-    BOOST_CHECK_EQUAL("", it->first);
-    BOOST_CHECK_EQUAL("3", it->second.data());
+    BOOST_TEST_EQ("", it->first);
+    BOOST_TEST_EQ("3", it->second.data());
     ++it;
-    BOOST_CHECK_EQUAL("", it->first);
+    BOOST_TEST_EQ("", it->first);
     {
         ptree& sub = it->second;
-        BOOST_CHECK_EQUAL("", sub.data());
-        BOOST_REQUIRE_EQUAL(2u, sub.size());
+        BOOST_TEST_EQ("", sub.data());
+        if(!BOOST_TEST_EQ(2u, sub.size()))
+            return;
         ptree::iterator iit = sub.begin();
-        BOOST_CHECK_EQUAL("", iit->first);
-        BOOST_CHECK_EQUAL("4", iit->second.data());
+        BOOST_TEST_EQ("", iit->first);
+        BOOST_TEST_EQ("4", iit->second.data());
         ++iit;
-        BOOST_CHECK_EQUAL("", iit->first);
-        BOOST_CHECK_EQUAL("5", iit->second.data());
+        BOOST_TEST_EQ("", iit->first);
+        BOOST_TEST_EQ("5", iit->second.data());
         ++iit;
-        BOOST_CHECK_EQUAL(sub.end(), iit);
+        BOOST_TEST(sub.end() == iit);
     }
     ++it;
-    BOOST_CHECK_EQUAL(tree.end(), it);
+    BOOST_TEST(tree.end() == it);
 }
 
-BOOST_AUTO_TEST_CASE(empty_object) {
+static void
+test_empty_object()
+{
     ptree tree;
     standard_parser<char> p;
     const char* input = " { }";
-    BOOST_REQUIRE(p.parse_object(input, tree));
-    BOOST_CHECK_EQUAL("", tree.data());
-    BOOST_CHECK_EQUAL(0u, tree.size());
+    if(BOOST_TEST(p.parse_object(input, tree)))
+    {
+        BOOST_TEST_EQ("", tree.data());
+        BOOST_TEST_EQ(0u, tree.size());
+    }
 }
 
-BOOST_AUTO_TEST_CASE(object_gets_tagged) {
+static void
+test_object_gets_tagged()
+{
     wptree tree;
     prefixing_parser<wchar_t> p;
     const wchar_t* input = L" { }";
-    BOOST_REQUIRE(p.parse_object(input, tree));
-    BOOST_CHECK_EQUAL(L"o:", tree.data());
-    BOOST_CHECK_EQUAL(0u, tree.size());
+    if(BOOST_TEST(p.parse_object(input, tree)))
+    {
+        BOOST_TEST(tree.data() == L"o:");
+        BOOST_TEST_EQ(0u, tree.size());
+    }
 }
 
-BOOST_AUTO_TEST_CASE(object_with_values) {
+static void
+test_object_with_values()
+{
     wptree tree;
     standard_parser<wchar_t> p;
     const wchar_t* input = L"{\n"
@@ -470,180 +537,210 @@ L"      \"1\":123, \"2\"\n"
 L"            :\"abc\" ,\"3\": true ,\n"
 L"      \"4\"   : null\n"
 L"  }";
-    BOOST_REQUIRE(p.parse_object(input, tree));
-    BOOST_REQUIRE_EQUAL(4u, tree.size());
-    wptree::iterator it = tree.begin();
-    BOOST_CHECK_EQUAL(L"1", it->first);
-    BOOST_CHECK_EQUAL(L"123", it->second.data());
-    ++it;
-    BOOST_CHECK_EQUAL(L"2", it->first);
-    BOOST_CHECK_EQUAL(L"abc", it->second.data());
-    ++it;
-    BOOST_CHECK_EQUAL(L"3", it->first);
-    BOOST_CHECK_EQUAL(L"true", it->second.data());
-    ++it;
-    BOOST_CHECK_EQUAL(L"4", it->first);
-    BOOST_CHECK_EQUAL(L"null", it->second.data());
-    ++it;
-    BOOST_CHECK_EQUAL(tree.end(), it);
+    if(BOOST_TEST(p.parse_object(input, tree)))
+        if(BOOST_TEST_EQ(4u, tree.size()))
+        {
+            wptree::iterator it = tree.begin();
+            BOOST_TEST(it->first == L"1");
+            BOOST_TEST(it->second.data() == L"123");
+            ++it;
+            BOOST_TEST(it->first == L"2");
+            BOOST_TEST(it->second.data() == L"abc");
+            ++it;
+            BOOST_TEST(it->first == L"3");
+            BOOST_TEST(it->second.data() == L"true");
+            ++it;
+            BOOST_TEST(it->first == L"4");
+            BOOST_TEST(it->second.data() == L"null");
+            ++it;
+            BOOST_TEST(tree.end() == it);
+        }
 }
 
-BOOST_AUTO_TEST_CASE(object_values_get_tagged) {
+static void
+test_object_values_get_tagged()
+{
     ptree tree;
     prefixing_parser<char> p;
     const char* input = "{\n"
         "\"1\": 123, \"2\": \"abc\" ,\"3\": true ,\n"
         "\"4\": null\n"
     "}";
-    BOOST_REQUIRE(p.parse_object(input, tree));
-    BOOST_REQUIRE_EQUAL(4u, tree.size());
-    BOOST_CHECK_EQUAL("o:", tree.data());
-    ptree::iterator it = tree.begin();
-    BOOST_CHECK_EQUAL("1", it->first);
-    BOOST_CHECK_EQUAL("n:123", it->second.data());
-    ++it;
-    BOOST_CHECK_EQUAL("2", it->first);
-    BOOST_CHECK_EQUAL("s:abc", it->second.data());
-    ++it;
-    BOOST_CHECK_EQUAL("3", it->first);
-    BOOST_CHECK_EQUAL("b:true", it->second.data());
-    ++it;
-    BOOST_CHECK_EQUAL("4", it->first);
-    BOOST_CHECK_EQUAL("_:null", it->second.data());
-    ++it;
-    BOOST_CHECK_EQUAL(tree.end(), it);
+    if(BOOST_TEST(p.parse_object(input, tree)))
+        if(BOOST_TEST_EQ(4u, tree.size()))
+        {
+            BOOST_TEST_EQ("o:", tree.data());
+            ptree::iterator it = tree.begin();
+            BOOST_TEST_EQ("1", it->first);
+            BOOST_TEST_EQ("n:123", it->second.data());
+            ++it;
+            BOOST_TEST_EQ("2", it->first);
+            BOOST_TEST_EQ("s:abc", it->second.data());
+            ++it;
+            BOOST_TEST_EQ("3", it->first);
+            BOOST_TEST_EQ("b:true", it->second.data());
+            ++it;
+            BOOST_TEST_EQ("4", it->first);
+            BOOST_TEST_EQ("_:null", it->second.data());
+            ++it;
+            BOOST_TEST(tree.end() == it);
+        }
 }
 
-BOOST_AUTO_TEST_CASE(nested_object) {
+static void
+test_nested_object()
+{
     ptree tree;
     standard_parser<char> p;
     const char* input = "{\"a\":{\"b\":1,\"c\":2},\"d\":3,\"e\":{\"f\":4,\"g\":5}}";
-    BOOST_REQUIRE(p.parse_object(input, tree));
-    BOOST_REQUIRE_EQUAL(3u, tree.size());
+    if(!BOOST_TEST(p.parse_object(input, tree)))
+        return;
+    if(!BOOST_TEST_EQ(3u, tree.size()))
+        return;
     ptree::iterator it = tree.begin();
-    BOOST_CHECK_EQUAL("a", it->first);
+    BOOST_TEST_EQ("a", it->first);
     {
         ptree& sub = it->second;
-        BOOST_CHECK_EQUAL("", sub.data());
-        BOOST_REQUIRE_EQUAL(2u, sub.size());
+        BOOST_TEST_EQ("", sub.data());
+        if(!BOOST_TEST_EQ(2u, sub.size()))
+            return;
         ptree::iterator iit = sub.begin();
-        BOOST_CHECK_EQUAL("b", iit->first);
-        BOOST_CHECK_EQUAL("1", iit->second.data());
+        BOOST_TEST_EQ("b", iit->first);
+        BOOST_TEST_EQ("1", iit->second.data());
         ++iit;
-        BOOST_CHECK_EQUAL("c", iit->first);
-        BOOST_CHECK_EQUAL("2", iit->second.data());
+        BOOST_TEST_EQ("c", iit->first);
+        BOOST_TEST_EQ("2", iit->second.data());
         ++iit;
-        BOOST_CHECK_EQUAL(sub.end(), iit);
+        BOOST_TEST(sub.end() == iit);
     }
     ++it;
-    BOOST_CHECK_EQUAL("d", it->first);
-    BOOST_CHECK_EQUAL("3", it->second.data());
+    BOOST_TEST_EQ("d", it->first);
+    BOOST_TEST_EQ("3", it->second.data());
     ++it;
-    BOOST_CHECK_EQUAL("e", it->first);
+    BOOST_TEST_EQ("e", it->first);
     {
         ptree& sub = it->second;
-        BOOST_CHECK_EQUAL("", sub.data());
-        BOOST_REQUIRE_EQUAL(2u, sub.size());
+        BOOST_TEST_EQ("", sub.data());
+        if(!BOOST_TEST_EQ(2u, sub.size()))
+            return;
         ptree::iterator iit = sub.begin();
-        BOOST_CHECK_EQUAL("f", iit->first);
-        BOOST_CHECK_EQUAL("4", iit->second.data());
+        BOOST_TEST_EQ("f", iit->first);
+        BOOST_TEST_EQ("4", iit->second.data());
         ++iit;
-        BOOST_CHECK_EQUAL("g", iit->first);
-        BOOST_CHECK_EQUAL("5", iit->second.data());
+        BOOST_TEST_EQ("g", iit->first);
+        BOOST_TEST_EQ("5", iit->second.data());
         ++iit;
-        BOOST_CHECK_EQUAL(sub.end(), iit);
+        BOOST_TEST(sub.end() == iit);
     }
     ++it;
-    BOOST_CHECK_EQUAL(tree.end(), it);
+    BOOST_TEST(tree.end() == it);
 }
 
-BOOST_AUTO_TEST_CASE(array_in_object) {
+static void
+test_array_in_object()
+{
     ptree tree;
     standard_parser<char> p;
     const char* input = "{\"a\":[1,2],\"b\":3,\"c\":[4,5]}";
-    BOOST_REQUIRE(p.parse_object(input, tree));
-    BOOST_REQUIRE_EQUAL(3u, tree.size());
+    if(!BOOST_TEST(p.parse_object(input, tree)))
+        return;
+    if(!BOOST_TEST_EQ(3u, tree.size()))
+        return;
     ptree::iterator it = tree.begin();
-    BOOST_CHECK_EQUAL("a", it->first);
+    BOOST_TEST_EQ("a", it->first);
     {
         ptree& sub = it->second;
-        BOOST_CHECK_EQUAL("", sub.data());
-        BOOST_REQUIRE_EQUAL(2u, sub.size());
-        ptree::iterator iit = sub.begin();
-        BOOST_CHECK_EQUAL("", iit->first);
-        BOOST_CHECK_EQUAL("1", iit->second.data());
-        ++iit;
-        BOOST_CHECK_EQUAL("", iit->first);
-        BOOST_CHECK_EQUAL("2", iit->second.data());
-        ++iit;
-        BOOST_CHECK_EQUAL(sub.end(), iit);
+        BOOST_TEST_EQ("", sub.data());
+        if(BOOST_TEST_EQ(2u, sub.size()))
+        {
+            ptree::iterator iit = sub.begin();
+            BOOST_TEST_EQ("", iit->first);
+            BOOST_TEST_EQ("1", iit->second.data());
+            ++iit;
+            BOOST_TEST_EQ("", iit->first);
+            BOOST_TEST_EQ("2", iit->second.data());
+            ++iit;
+            BOOST_TEST(sub.end() == iit);
+        }
     }
     ++it;
-    BOOST_CHECK_EQUAL("b", it->first);
-    BOOST_CHECK_EQUAL("3", it->second.data());
+    BOOST_TEST_EQ("b", it->first);
+    BOOST_TEST_EQ("3", it->second.data());
     ++it;
-    BOOST_CHECK_EQUAL("c", it->first);
+    BOOST_TEST_EQ("c", it->first);
     {
         ptree& sub = it->second;
-        BOOST_CHECK_EQUAL("", sub.data());
-        BOOST_REQUIRE_EQUAL(2u, sub.size());
-        ptree::iterator iit = sub.begin();
-        BOOST_CHECK_EQUAL("", iit->first);
-        BOOST_CHECK_EQUAL("4", iit->second.data());
-        ++iit;
-        BOOST_CHECK_EQUAL("", iit->first);
-        BOOST_CHECK_EQUAL("5", iit->second.data());
-        ++iit;
-        BOOST_CHECK_EQUAL(sub.end(), iit);
+        BOOST_TEST_EQ("", sub.data());
+        if(BOOST_TEST_EQ(2u, sub.size()))
+        {
+            ptree::iterator iit = sub.begin();
+            BOOST_TEST_EQ("", iit->first);
+            BOOST_TEST_EQ("4", iit->second.data());
+            ++iit;
+            BOOST_TEST_EQ("", iit->first);
+            BOOST_TEST_EQ("5", iit->second.data());
+            ++iit;
+            BOOST_TEST(sub.end() == iit);
+        }
     }
     ++it;
-    BOOST_CHECK_EQUAL(tree.end(), it);
+    BOOST_TEST(tree.end() == it);
 }
 
-BOOST_AUTO_TEST_CASE(object_in_array) {
+static void
+test_object_in_array()
+{
     ptree tree;
     standard_parser<char> p;
     const char* input = "[{\"a\":1,\"b\":2},3,{\"c\":4,\"d\":5}]";
-    BOOST_REQUIRE(p.parse_array(input, tree));
-    BOOST_REQUIRE_EQUAL(3u, tree.size());
+    if(!BOOST_TEST(p.parse_array(input, tree)))
+        return;
+    if(!BOOST_TEST_EQ(3u, tree.size()))
+        return;
     ptree::iterator it = tree.begin();
-    BOOST_CHECK_EQUAL("", it->first);
+    BOOST_TEST_EQ("", it->first);
     {
         ptree& sub = it->second;
-        BOOST_CHECK_EQUAL("", sub.data());
-        BOOST_REQUIRE_EQUAL(2u, sub.size());
-        ptree::iterator iit = sub.begin();
-        BOOST_CHECK_EQUAL("a", iit->first);
-        BOOST_CHECK_EQUAL("1", iit->second.data());
-        ++iit;
-        BOOST_CHECK_EQUAL("b", iit->first);
-        BOOST_CHECK_EQUAL("2", iit->second.data());
-        ++iit;
-        BOOST_CHECK_EQUAL(sub.end(), iit);
+        BOOST_TEST_EQ("", sub.data());
+        if(BOOST_TEST_EQ(2u, sub.size()))
+        {
+            ptree::iterator iit = sub.begin();
+            BOOST_TEST_EQ("a", iit->first);
+            BOOST_TEST_EQ("1", iit->second.data());
+            ++iit;
+            BOOST_TEST_EQ("b", iit->first);
+            BOOST_TEST_EQ("2", iit->second.data());
+            ++iit;
+            BOOST_TEST(sub.end() == iit);
+        }
     }
     ++it;
-    BOOST_CHECK_EQUAL("", it->first);
-    BOOST_CHECK_EQUAL("3", it->second.data());
+    BOOST_TEST_EQ("", it->first);
+    BOOST_TEST_EQ("3", it->second.data());
     ++it;
-    BOOST_CHECK_EQUAL("", it->first);
+    BOOST_TEST_EQ("", it->first);
     {
         ptree& sub = it->second;
-        BOOST_CHECK_EQUAL("", sub.data());
-        BOOST_REQUIRE_EQUAL(2u, sub.size());
-        ptree::iterator iit = sub.begin();
-        BOOST_CHECK_EQUAL("c", iit->first);
-        BOOST_CHECK_EQUAL("4", iit->second.data());
-        ++iit;
-        BOOST_CHECK_EQUAL("d", iit->first);
-        BOOST_CHECK_EQUAL("5", iit->second.data());
-        ++iit;
-        BOOST_CHECK_EQUAL(sub.end(), iit);
+        BOOST_TEST_EQ("", sub.data());
+        if(BOOST_TEST_EQ(2u, sub.size()))
+        {
+            ptree::iterator iit = sub.begin();
+            BOOST_TEST_EQ("c", iit->first);
+            BOOST_TEST_EQ("4", iit->second.data());
+            ++iit;
+            BOOST_TEST_EQ("d", iit->first);
+            BOOST_TEST_EQ("5", iit->second.data());
+            ++iit;
+            BOOST_TEST(sub.end() == iit);
+        }
     }
     ++it;
-    BOOST_CHECK_EQUAL(tree.end(), it);
+    BOOST_TEST(tree.end() == it);
 }
 
-BOOST_AUTO_TEST_CASE(parser_works_with_input_iterators) {
+static void
+test_parser_works_with_input_iterators()
+{
     const char* input = " {\n"
 "       \"1\":123, \"2\"\n"
 "            :\"abc\" ,\"3\": true ,\n"
@@ -664,39 +761,41 @@ BOOST_AUTO_TEST_CASE(parser_works_with_input_iterators) {
     p.parse_value();
 
     const ptree& tree = callbacks.output();
-    BOOST_REQUIRE_EQUAL(5u, tree.size());
+    if(!BOOST_TEST_EQ(5u, tree.size()))
+        return;
     ptree::const_iterator it = tree.begin();
-    BOOST_CHECK_EQUAL("1", it->first);
-    BOOST_CHECK_EQUAL("123", it->second.data());
+    BOOST_TEST_EQ("1", it->first);
+    BOOST_TEST_EQ("123", it->second.data());
     ++it;
-    BOOST_CHECK_EQUAL("2", it->first);
-    BOOST_CHECK_EQUAL("abc", it->second.data());
+    BOOST_TEST_EQ("2", it->first);
+    BOOST_TEST_EQ("abc", it->second.data());
     ++it;
-    BOOST_CHECK_EQUAL("3", it->first);
-    BOOST_CHECK_EQUAL("true", it->second.data());
+    BOOST_TEST_EQ("3", it->first);
+    BOOST_TEST_EQ("true", it->second.data());
     ++it;
-    BOOST_CHECK_EQUAL("4", it->first);
-    BOOST_CHECK_EQUAL("null", it->second.data());
+    BOOST_TEST_EQ("4", it->first);
+    BOOST_TEST_EQ("null", it->second.data());
     ++it;
-    BOOST_CHECK_EQUAL("5", it->first);
+    BOOST_TEST_EQ("5", it->first);
     {
         const ptree& sub = it->second;
-        BOOST_CHECK_EQUAL("", sub.data());
-        BOOST_REQUIRE_EQUAL(3u, sub.size());
+        BOOST_TEST_EQ("", sub.data());
+        if(!BOOST_TEST_EQ(3u, sub.size()))
+            return;
         ptree::const_iterator iit = sub.begin();
-        BOOST_CHECK_EQUAL("", iit->first);
-        BOOST_CHECK_EQUAL("1", iit->second.data());
+        BOOST_TEST_EQ("", iit->first);
+        BOOST_TEST_EQ("1", iit->second.data());
         ++iit;
-        BOOST_CHECK_EQUAL("", iit->first);
-        BOOST_CHECK_EQUAL("23", iit->second.data());
+        BOOST_TEST_EQ("", iit->first);
+        BOOST_TEST_EQ("23", iit->second.data());
         ++iit;
-        BOOST_CHECK_EQUAL("", iit->first);
-        BOOST_CHECK_EQUAL("456", iit->second.data());
+        BOOST_TEST_EQ("", iit->first);
+        BOOST_TEST_EQ("456", iit->second.data());
         ++iit;
-        BOOST_CHECK_EQUAL(sub.end(), iit);
+        BOOST_TEST(sub.end() == iit);
     }
     ++it;
-    BOOST_CHECK_EQUAL(tree.end(), it);
+    BOOST_TEST(tree.end() == it);
 }
 
 struct bad_parse_n {
@@ -704,19 +803,28 @@ struct bad_parse_n {
     const char* message_substring;
 };
 
-void parse_error_thrown_with_message_n(bad_parse_n param) {
-    try {
-        standard_parser<char> p;
-        ptree dummy;
-        p.parse_value(param.json, dummy);
-        BOOST_FAIL("expected exception");
-    } catch (json_parser::json_parser_error& e) {
-        std::string message = e.message();
-        BOOST_CHECK_MESSAGE(message.find(param.message_substring) !=
-                                std::string::npos,
-                            "bad error message on input '" << param.json
-                                << "', need: '" << param.message_substring
-                                << "' but found '" << message << "'");
+template<std::size_t N>
+void test_parse_error_thrown_with_message_n(bad_parse_n const (&param)[N])
+{
+    for(std::size_t i = 0 ; i < N ; ++i)
+    {
+        try {
+            standard_parser<char> p;
+            ptree dummy;
+            p.parse_value(param[i].json, dummy);
+            BOOST_ERROR("expected exception");
+        } catch (json_parser::json_parser_error& e) {
+            std::string message = e.message();
+            if(message.find(param[i].message_substring) ==
+                                    std::string::npos)
+            {
+                std::ostringstream ss;
+                ss << "bad error message on input '" << param[i].json
+                    << "', need: '" << param[i].message_substring
+                    << "' but found '" << message << "'";
+                BOOST_ERROR(ss.str().c_str());
+            }
+        }
     }
 }
 
@@ -812,23 +920,53 @@ struct bad_parse_w {
     const char* message_substring;
 };
 
-void parse_error_thrown_with_message_w(bad_parse_w param) {
-    try {
-        standard_parser<wchar_t> p;
-        wptree dummy;
-        p.parse_value(param.json, dummy);
-        BOOST_FAIL("expected exception");
-    } catch (json_parser::json_parser_error& e) {
-        std::string message = e.message();
-        BOOST_CHECK_MESSAGE(message.find(param.message_substring) !=
-                                std::string::npos,
-                            "bad error message on input '" << param.json
-                                << "', need: '" << param.message_substring
-                                << "' but found '" << message << "'");
+struct do_narrow
+{
+    char operator()(std::wstring::value_type w) const
+    {
+        unsigned long u = static_cast<unsigned long>(w);
+        if (u < 32 || u > 126)
+            return '?';
+        else
+            return static_cast<char>(u);
+    }
+};
+static std::string
+make_narrow(std::wstring const& in)
+{
+    std::string result(in.size(), ' ');
+    std::transform(in.begin(), in.end(), result.begin(), do_narrow());
+    return result;
+}
+
+template<std::size_t N>
+void
+test_parse_error_thrown_with_message_w(bad_parse_w const (&param)[N])
+{
+    for(std::size_t i = 0 ; i < N ; ++i)
+    {
+        try {
+            standard_parser<wchar_t> p;
+            wptree dummy;
+            p.parse_value(param[i].json, dummy);
+            BOOST_ERROR("expected exception");
+        } catch (json_parser::json_parser_error& e) {
+            std::string message = e.message();
+            if (message.find(param[i].message_substring) ==
+                                    std::string::npos)
+            {
+                std::ostringstream ss;
+                ss << "bad error message on input '" << make_narrow(param[i].json)
+                                    << "', need: '" << param[i].message_substring
+                                    << "' but found '" << message << "'";
+                BOOST_ERROR(ss.str().c_str());
+            }
+        }
     }
 }
 
-const bad_parse_w errors_w[] = {
+const bad_parse_w
+errors_w[] = {
     {L"", "expected value"},
     {L"(", "expected value"},
 
@@ -911,15 +1049,45 @@ const bad_parse_w errors_w[] = {
     {L"{\"\":0,}", "expected key string"},
 };
 
-template <typename T, std::size_t N>
-std::size_t arraysize(T(&)[N]) { return N; }
+int main()
+{
+    test_null_parse_result_is_input();
+    test_uses_traits_from_null();
+    test_null_parse_skips_bom();
+    test_null_parse_result_is_input_w();
+    test_null_parse_skips_bom_w();
+    test_uses_traits_from_boolean_n();
+    test_uses_traits_from_boolean_w();
+    test_boolean_parse_result_is_input_n(booleans_n);
+    test_boolean_parse_result_is_input_w(booleans_w);
+    test_number_parse_result_is_input_n(numbers_n);
+    test_number_parse_result_is_input_w(numbers_w);
+    test_uses_traits_from_number_n();
+    test_string_parsed_correctly_n(strings_n);
+    test_string_parsed_correctly_w(strings_w);
+    test_parse_error_thrown_with_message_n(errors_n);
+    test_parse_error_thrown_with_message_w(errors_w);
+    test_uses_string_callbacks();
+    test_empty_array();
+    test_array_with_values();
+    test_array_values_get_tagged();
+    test_nested_array();
+    test_empty_object();
+    test_object_gets_tagged();
+    test_object_with_values();
+    test_object_values_get_tagged();
+    test_nested_object();
+    test_array_in_object();
+    test_object_in_array();
+    test_parser_works_with_input_iterators();
+    test_uses_traits_from_null_w();
+    test_uses_traits_from_number_w();
+    test_array_gets_tagged();
+    return boost::report_errors();
+}
 
-#define ARRAY_TEST_CASE(fn, a) \
-    BOOST_PARAM_TEST_CASE(fn, (a), (a) + arraysize((a)))
-
-using namespace boost::unit_test;
-
-test_suite* init_unit_test_suite(int, char*[]) 
+/*
+test_suite* init_unit_test_suite(int, char*[])
 {
     master_test_suite_t& ts = boost::unit_test::framework::master_test_suite();
     ts.add(ARRAY_TEST_CASE(boolean_parse_result_is_input_n, booleans_n));
@@ -933,3 +1101,4 @@ test_suite* init_unit_test_suite(int, char*[])
 
     return 0;
 }
+*/
\ No newline at end of file
diff --git a/test/test_property_tree.cpp b/test/test_property_tree.cpp
index 55ff5a8..ba1b9fb 100644
--- a/test/test_property_tree.cpp
+++ b/test/test_property_tree.cpp
@@ -12,7 +12,6 @@
 #include <boost/range.hpp>
 #include <list>
 #include <cmath>
-#include <iostream>
 
 // If using VC, disable some warnings that trip in boost::serialization bowels
 #ifdef BOOST_MSVC
@@ -166,7 +165,7 @@ void run_tests(Ptree* pt)
     test_leaks(pt);                  // must be a final test
 }
 
-int test_main(int, char *[])
+int main(int, char *[])
 {
     
     using namespace boost::property_tree;
@@ -199,5 +198,5 @@ int test_main(int, char *[])
     }
 #endif
 
-    return 0;
+    return boost::report_errors();
 }
diff --git a/test/test_property_tree.hpp b/test/test_property_tree.hpp
index 3247373..bd4a764 100644
--- a/test/test_property_tree.hpp
+++ b/test/test_property_tree.hpp
@@ -18,42 +18,42 @@ void test_debug(PTREE *)
 {
 #if 0
     // Check count
-    BOOST_CHECK(PTREE::debug_get_instances_count() == 0);
+    BOOST_TEST(PTREE::debug_get_instances_count() == 0);
 
     {
 
         // Create ptrees
         PTREE pt1, pt2;
-        BOOST_CHECK(PTREE::debug_get_instances_count() == 2);
+        BOOST_TEST(PTREE::debug_get_instances_count() == 2);
 
         // Create PTREE
         PTREE *pt3 = new PTREE;
-        BOOST_CHECK(PTREE::debug_get_instances_count() == 3);
+        BOOST_TEST(PTREE::debug_get_instances_count() == 3);
 
         // Insert
         pt1.push_back(std::make_pair(T("key"), *pt3));
-        BOOST_CHECK(PTREE::debug_get_instances_count() == 4);
+        BOOST_TEST(PTREE::debug_get_instances_count() == 4);
 
         // Insert
         pt2.push_back(std::make_pair(T("key"), *pt3));
-        BOOST_CHECK(PTREE::debug_get_instances_count() == 5);
+        BOOST_TEST(PTREE::debug_get_instances_count() == 5);
 
         // Clear
         pt1.clear();
-        BOOST_CHECK(PTREE::debug_get_instances_count() == 4);
+        BOOST_TEST(PTREE::debug_get_instances_count() == 4);
 
         // Clear
         pt2.clear();
-        BOOST_CHECK(PTREE::debug_get_instances_count() == 3);
+        BOOST_TEST(PTREE::debug_get_instances_count() == 3);
 
         // Delete
         delete pt3;
-        BOOST_CHECK(PTREE::debug_get_instances_count() == 2);
+        BOOST_TEST(PTREE::debug_get_instances_count() == 2);
 
     }
 
     // Check count
-    BOOST_CHECK(PTREE::debug_get_instances_count() == 0);
+    BOOST_TEST(PTREE::debug_get_instances_count() == 0);
 #endif
 }
 
@@ -64,45 +64,45 @@ void test_constructor_destructor_assignment(PTREE *)
 
         // Test constructor from string
         PTREE pt1(T("data"));
-        BOOST_CHECK(pt1.data() == T("data"));
-        //BOOST_CHECK(PTREE::debug_get_instances_count() == 1);
+        BOOST_TEST(pt1.data() == T("data"));
+        //BOOST_TEST(PTREE::debug_get_instances_count() == 1);
 
         // Do insertions
         PTREE &tmp1 = pt1.put(T("key1"), T("data1"));
         PTREE &tmp2 = pt1.put(T("key2"), T("data2"));
         tmp1.put(T("key3"), T("data3"));
         tmp2.put(T("key4"), T("data4"));
-        //BOOST_CHECK(PTREE::debug_get_instances_count() == 5);
+        //BOOST_TEST(PTREE::debug_get_instances_count() == 5);
 
         // Make a copy using copy constructor
         PTREE *pt2 = new PTREE(pt1);
-        BOOST_CHECK(*pt2 == pt1);
-        //BOOST_CHECK(PTREE::debug_get_instances_count() == 10);
+        BOOST_TEST(*pt2 == pt1);
+        //BOOST_TEST(PTREE::debug_get_instances_count() == 10);
 
         // Make a copy using = operator
         PTREE *pt3 = new PTREE;
         *pt3 = *pt2;
-        BOOST_CHECK(*pt3 == *pt2);
-        //BOOST_CHECK(PTREE::debug_get_instances_count() == 15);
+        BOOST_TEST(*pt3 == *pt2);
+        //BOOST_TEST(PTREE::debug_get_instances_count() == 15);
 
         // Test self assignment
         pt1 = pt1;
-        BOOST_CHECK(pt1 == *pt2);
-        BOOST_CHECK(pt1 == *pt3);
-        //BOOST_CHECK(PTREE::debug_get_instances_count() == 15);
+        BOOST_TEST(pt1 == *pt2);
+        BOOST_TEST(pt1 == *pt3);
+        //BOOST_TEST(PTREE::debug_get_instances_count() == 15);
 
         // Destroy
         delete pt2;
-        //BOOST_CHECK(PTREE::debug_get_instances_count() == 10);
+        //BOOST_TEST(PTREE::debug_get_instances_count() == 10);
 
         // Destroy
         delete pt3;
-        //BOOST_CHECK(PTREE::debug_get_instances_count() == 5);
+        //BOOST_TEST(PTREE::debug_get_instances_count() == 5);
 
     }
 
     // Check count
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 0);
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 0);
 
 }
 
@@ -122,23 +122,23 @@ void test_insertion(PTREE *)
     it2->second.insert(it2->second.end(), it1->second.begin(), it1->second.end());
 
     // Check instance count
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 11);
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 11);
 
     // Check contents
-    BOOST_CHECK(pt.get(T("key1"), T("")) == T("data1"));
-    BOOST_CHECK(pt.get(T("key2"), T("")) == T("data2"));
-    BOOST_CHECK(pt.get(T("key1.key3"), T("")) == T("data3"));
-    BOOST_CHECK(pt.get(T("key1.key4"), T("")) == T("data4"));
-    BOOST_CHECK(pt.get(T("key2.key3"), T("")) == T("data3"));
-    BOOST_CHECK(pt.get(T("key2.key4"), T("")) == T("data4"));
+    BOOST_TEST(pt.get(T("key1"), T("")) == T("data1"));
+    BOOST_TEST(pt.get(T("key2"), T("")) == T("data2"));
+    BOOST_TEST(pt.get(T("key1.key3"), T("")) == T("data3"));
+    BOOST_TEST(pt.get(T("key1.key4"), T("")) == T("data4"));
+    BOOST_TEST(pt.get(T("key2.key3"), T("")) == T("data3"));
+    BOOST_TEST(pt.get(T("key2.key4"), T("")) == T("data4"));
 
     // Check sequence
     PTREE::iterator it = it2;
-    ++it; BOOST_CHECK(it == it1);
-    ++it; BOOST_CHECK(it == pt.end());
+    ++it; BOOST_TEST(it == it1);
+    ++it; BOOST_TEST(it == pt.end());
     it = it4; 
-    ++it; BOOST_CHECK(it == it3);
-    ++it; BOOST_CHECK(it == it1->second.end());
+    ++it; BOOST_TEST(it == it3);
+    ++it; BOOST_TEST(it == it1->second.end());
 
 }
 
@@ -158,27 +158,27 @@ void test_erasing(PTREE *)
     it2->second.insert(it2->second.end(), it1->second.begin(), it1->second.end());
 
     // Check instance count
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 11);
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 11);
 
     // Test range erase
     PTREE::iterator it = it1->second.erase(it1->second.begin(), it1->second.end());
-    BOOST_CHECK(it == it1->second.end());
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 9);
+    BOOST_TEST(it == it1->second.end());
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 9);
 
     // Test single erase
     PTREE::size_type n = pt.erase(T("key1"));
-    BOOST_CHECK(n == 1);
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 8);
+    BOOST_TEST(n == 1);
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 8);
 
     // Test multiple erase
     n = it2->second.erase(T("key"));
-    BOOST_CHECK(n == 2);
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 6);
+    BOOST_TEST(n == 2);
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 6);
 
     // Test one more erase
     n = pt.erase(T("key2"));
-    BOOST_CHECK(n == 1);
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 5);
+    BOOST_TEST(n == 1);
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 5);
 
 }
 
@@ -190,13 +190,13 @@ void test_clear(PTREE *)
     pt.push_back(std::make_pair(T("key"), PTREE(T("data"))));
 
     // Check instance count
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 2);
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 2);
 
     // Test clear
     pt.clear();
-    BOOST_CHECK(pt.empty());
-    BOOST_CHECK(pt.data().empty());
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 1);
+    BOOST_TEST(pt.empty());
+    BOOST_TEST(pt.data().empty());
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 1);
 
 }
 
@@ -215,32 +215,32 @@ void test_pushpop(PTREE *)
     pt.push_front(std::make_pair(T("key1"), tmp1));
 
     // Check instance count
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 9);
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 9);
 
     // Check sequence
     PTREE::iterator it = pt.begin();
-    BOOST_CHECK(it->first == T("key1")); ++it;
-    BOOST_CHECK(it->first == T("key2")); ++it;
-    BOOST_CHECK(it->first == T("key3")); ++it;
-    BOOST_CHECK(it->first == T("key4")); ++it;
-    BOOST_CHECK(it == pt.end());
+    BOOST_TEST(it->first == T("key1")); ++it;
+    BOOST_TEST(it->first == T("key2")); ++it;
+    BOOST_TEST(it->first == T("key3")); ++it;
+    BOOST_TEST(it->first == T("key4")); ++it;
+    BOOST_TEST(it == pt.end());
 
     // Test pops
     pt.pop_back();
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 8);
-    BOOST_CHECK(pt.front().second.data() == T("data1"));
-    BOOST_CHECK(pt.back().second.data() == T("data3"));
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 8);
+    BOOST_TEST(pt.front().second.data() == T("data1"));
+    BOOST_TEST(pt.back().second.data() == T("data3"));
     pt.pop_front();
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 7);
-    BOOST_CHECK(pt.front().second.data() == T("data2"));
-    BOOST_CHECK(pt.back().second.data() == T("data3"));
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 7);
+    BOOST_TEST(pt.front().second.data() == T("data2"));
+    BOOST_TEST(pt.back().second.data() == T("data3"));
     pt.pop_back();
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 6);
-    BOOST_CHECK(pt.front().second.data() == T("data2"));
-    BOOST_CHECK(pt.back().second.data() == T("data2"));
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 6);
+    BOOST_TEST(pt.front().second.data() == T("data2"));
+    BOOST_TEST(pt.back().second.data() == T("data2"));
     pt.pop_front();
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 5);
-    BOOST_CHECK(pt.empty());
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 5);
+    BOOST_TEST(pt.empty());
 
 }
 
@@ -257,41 +257,41 @@ void test_container_iteration(PTREE *)
     // iterator
     {
         PTREE::iterator it = pt.begin();
-        BOOST_CHECK(it->first == T("key3")); ++it;
-        BOOST_CHECK(it->first == T("key1")); ++it;
-        BOOST_CHECK(it->first == T("key4")); ++it;
-        BOOST_CHECK(it->first == T("key2")); ++it;
-        BOOST_CHECK(it == pt.end());
+        BOOST_TEST(it->first == T("key3")); ++it;
+        BOOST_TEST(it->first == T("key1")); ++it;
+        BOOST_TEST(it->first == T("key4")); ++it;
+        BOOST_TEST(it->first == T("key2")); ++it;
+        BOOST_TEST(it == pt.end());
     }
 
     // const_iterator
     {
         PTREE::const_iterator it = pt.begin();
-        BOOST_CHECK(it->first == T("key3")); ++it;
-        BOOST_CHECK(it->first == T("key1")); ++it;
-        BOOST_CHECK(it->first == T("key4")); ++it;
-        BOOST_CHECK(it->first == T("key2")); ++it;
-        BOOST_CHECK(it == pt.end());
+        BOOST_TEST(it->first == T("key3")); ++it;
+        BOOST_TEST(it->first == T("key1")); ++it;
+        BOOST_TEST(it->first == T("key4")); ++it;
+        BOOST_TEST(it->first == T("key2")); ++it;
+        BOOST_TEST(it == pt.end());
     }
 
     // reverse_iterator
     {
         PTREE::reverse_iterator it = pt.rbegin();
-        BOOST_CHECK(it->first == T("key2")); ++it;
-        BOOST_CHECK(it->first == T("key4")); ++it;
-        BOOST_CHECK(it->first == T("key1")); ++it;
-        BOOST_CHECK(it->first == T("key3")); ++it;
-        BOOST_CHECK(it == pt.rend());
+        BOOST_TEST(it->first == T("key2")); ++it;
+        BOOST_TEST(it->first == T("key4")); ++it;
+        BOOST_TEST(it->first == T("key1")); ++it;
+        BOOST_TEST(it->first == T("key3")); ++it;
+        BOOST_TEST(it == pt.rend());
     }
 
     // const_reverse_iterator
     {
         PTREE::const_reverse_iterator it = pt.rbegin();
-        BOOST_CHECK(it->first == T("key2")); ++it;
-        BOOST_CHECK(it->first == T("key4")); ++it;
-        BOOST_CHECK(it->first == T("key1")); ++it;
-        BOOST_CHECK(it->first == T("key3")); ++it;
-        BOOST_CHECK(it == PTREE::const_reverse_iterator(pt.rend()));
+        BOOST_TEST(it->first == T("key2")); ++it;
+        BOOST_TEST(it->first == T("key4")); ++it;
+        BOOST_TEST(it->first == T("key1")); ++it;
+        BOOST_TEST(it->first == T("key3")); ++it;
+        BOOST_TEST(it == PTREE::const_reverse_iterator(pt.rend()));
     }
 
 }
@@ -308,37 +308,37 @@ void test_swap(PTREE *)
     pt1.put(T("key1.key4"), T(""));
 
     // Check counts
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 6);
-    BOOST_CHECK(pt1.size() == 2);
-    BOOST_CHECK(pt1.get_child(T("key1")).size() == 2);
-    BOOST_CHECK(pt2.size() == 0);
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 6);
+    BOOST_TEST(pt1.size() == 2);
+    BOOST_TEST(pt1.get_child(T("key1")).size() == 2);
+    BOOST_TEST(pt2.size() == 0);
 
     // Swap using member function
     pt1.swap(pt2);
     
     // Check counts
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 6);
-    BOOST_CHECK(pt2.size() == 2);
-    BOOST_CHECK(pt2.get_child(T("key1")).size() == 2);
-    BOOST_CHECK(pt1.size() == 0);
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 6);
+    BOOST_TEST(pt2.size() == 2);
+    BOOST_TEST(pt2.get_child(T("key1")).size() == 2);
+    BOOST_TEST(pt1.size() == 0);
 
     // Swap using free function
     swap(pt1, pt2);
 
     // Check counts
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 6);
-    BOOST_CHECK(pt1.size() == 2);
-    BOOST_CHECK(pt1.get_child(T("key1")).size() == 2);
-    BOOST_CHECK(pt2.size() == 0);
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 6);
+    BOOST_TEST(pt1.size() == 2);
+    BOOST_TEST(pt1.get_child(T("key1")).size() == 2);
+    BOOST_TEST(pt2.size() == 0);
 
     // Swap using std algorithm
     std::swap(pt1, pt2);
 
     // Check counts
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 6);
-    BOOST_CHECK(pt2.size() == 2);
-    BOOST_CHECK(pt2.get_child(T("key1")).size() == 2);
-    BOOST_CHECK(pt1.size() == 0);
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 6);
+    BOOST_TEST(pt2.size() == 2);
+    BOOST_TEST(pt2.get_child(T("key1")).size() == 2);
+    BOOST_TEST(pt1.size() == 0);
 
 }
 
@@ -361,20 +361,20 @@ void test_sort_reverse(PTREE *)
     // Check sequence
     {
         PTREE::iterator it = pt.begin();
-        BOOST_CHECK(it->first == T("key3")); ++it;
-        BOOST_CHECK(it->first == T("key4")); ++it;
-        BOOST_CHECK(it->first == T("key1")); ++it;
-        BOOST_CHECK(it->first == T("key2")); ++it;
-        BOOST_CHECK(it == pt.end());
+        BOOST_TEST(it->first == T("key3")); ++it;
+        BOOST_TEST(it->first == T("key4")); ++it;
+        BOOST_TEST(it->first == T("key1")); ++it;
+        BOOST_TEST(it->first == T("key2")); ++it;
+        BOOST_TEST(it == pt.end());
     }
     // Check sequence using find to check if index is ok
     {
         PTREE::iterator it = pt.begin();
-        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key3")))); ++it;
-        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key4")))); ++it;
-        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key1")))); ++it;
-        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key2")))); ++it;
-        BOOST_CHECK(it == pt.end());
+        BOOST_TEST(it == pt.to_iterator(pt.find(T("key3")))); ++it;
+        BOOST_TEST(it == pt.to_iterator(pt.find(T("key4")))); ++it;
+        BOOST_TEST(it == pt.to_iterator(pt.find(T("key1")))); ++it;
+        BOOST_TEST(it == pt.to_iterator(pt.find(T("key2")))); ++it;
+        BOOST_TEST(it == pt.end());
     }
 
     // Sort
@@ -383,20 +383,20 @@ void test_sort_reverse(PTREE *)
     // Check sequence
     {
         PTREE::iterator it = pt.begin();
-        BOOST_CHECK(it->first == T("key1")); ++it;
-        BOOST_CHECK(it->first == T("key2")); ++it;
-        BOOST_CHECK(it->first == T("key3")); ++it;
-        BOOST_CHECK(it->first == T("key4")); ++it;
-        BOOST_CHECK(it == pt.end());
+        BOOST_TEST(it->first == T("key1")); ++it;
+        BOOST_TEST(it->first == T("key2")); ++it;
+        BOOST_TEST(it->first == T("key3")); ++it;
+        BOOST_TEST(it->first == T("key4")); ++it;
+        BOOST_TEST(it == pt.end());
     }
     // Check sequence (using find to check if index is ok)
     {
         PTREE::iterator it = pt.begin();
-        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key1")))); ++it;
-        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key2")))); ++it;
-        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key3")))); ++it;
-        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key4")))); ++it;
-        BOOST_CHECK(it == pt.end());
+        BOOST_TEST(it == pt.to_iterator(pt.find(T("key1")))); ++it;
+        BOOST_TEST(it == pt.to_iterator(pt.find(T("key2")))); ++it;
+        BOOST_TEST(it == pt.to_iterator(pt.find(T("key3")))); ++it;
+        BOOST_TEST(it == pt.to_iterator(pt.find(T("key4")))); ++it;
+        BOOST_TEST(it == pt.end());
     }
     
     // Sort reverse
@@ -405,20 +405,20 @@ void test_sort_reverse(PTREE *)
     // Check sequence
     {
         PTREE::iterator it = pt.begin();
-        BOOST_CHECK(it->first == T("key4")); ++it;
-        BOOST_CHECK(it->first == T("key3")); ++it;
-        BOOST_CHECK(it->first == T("key2")); ++it;
-        BOOST_CHECK(it->first == T("key1")); ++it;
-        BOOST_CHECK(it == pt.end());
+        BOOST_TEST(it->first == T("key4")); ++it;
+        BOOST_TEST(it->first == T("key3")); ++it;
+        BOOST_TEST(it->first == T("key2")); ++it;
+        BOOST_TEST(it->first == T("key1")); ++it;
+        BOOST_TEST(it == pt.end());
     }
     // Check sequence (using find to check if index is ok)
     {
         PTREE::iterator it = pt.begin();
-        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key4")))); ++it;
-        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key3")))); ++it;
-        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key2")))); ++it;
-        BOOST_CHECK(it == pt.to_iterator(pt.find(T("key1")))); ++it;
-        BOOST_CHECK(it == pt.end());
+        BOOST_TEST(it == pt.to_iterator(pt.find(T("key4")))); ++it;
+        BOOST_TEST(it == pt.to_iterator(pt.find(T("key3")))); ++it;
+        BOOST_TEST(it == pt.to_iterator(pt.find(T("key2")))); ++it;
+        BOOST_TEST(it == pt.to_iterator(pt.find(T("key1")))); ++it;
+        BOOST_TEST(it == pt.end());
     }
 
 }
@@ -435,17 +435,17 @@ void test_case(PTREE *)
 
     // Check findings depending on traits type
 #if (NOCASE == 0)
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 7);
-    BOOST_CHECK(pt.get(T("key1"), T("")) == T("data1"));
-    BOOST_CHECK(pt.get(T("key2"), T("")) == T(""));
-    BOOST_CHECK(pt.get(T("key1.key3"), T("")) == T(""));
-    BOOST_CHECK(pt.get(T("KEY1.key4"), T("")) == T("data4"));
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 7);
+    BOOST_TEST(pt.get(T("key1"), T("")) == T("data1"));
+    BOOST_TEST(pt.get(T("key2"), T("")) == T(""));
+    BOOST_TEST(pt.get(T("key1.key3"), T("")) == T(""));
+    BOOST_TEST(pt.get(T("KEY1.key4"), T("")) == T("data4"));
 #else
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 5);
-    BOOST_CHECK(pt.get(T("key1"), T("1")) == pt.get(T("KEY1"), T("2")));
-    BOOST_CHECK(pt.get(T("key2"), T("1")) == pt.get(T("KEY2"), T("2")));
-    BOOST_CHECK(pt.get(T("key1.key3"), T("1")) == pt.get(T("KEY1.KEY3"), T("2")));
-    BOOST_CHECK(pt.get(T("key1.key4"), T("1")) == pt.get(T("KEY1.KEY4"), T("2")));
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 5);
+    BOOST_TEST(pt.get(T("key1"), T("1")) == pt.get(T("KEY1"), T("2")));
+    BOOST_TEST(pt.get(T("key2"), T("1")) == pt.get(T("KEY2"), T("2")));
+    BOOST_TEST(pt.get(T("key1.key3"), T("1")) == pt.get(T("KEY1.KEY3"), T("2")));
+    BOOST_TEST(pt.get(T("key1.key4"), T("1")) == pt.get(T("KEY1.KEY4"), T("2")));
 #endif
 
     // Do more insertions
@@ -454,19 +454,19 @@ void test_case(PTREE *)
 
     // Test counts
 #if (NOCASE == 0)
-    BOOST_CHECK(pt.count(T("key1")) == 3);
-    BOOST_CHECK(pt.count(T("KEY1")) == 1);
-    BOOST_CHECK(pt.count(T("key2")) == 0);
-    BOOST_CHECK(pt.count(T("KEY2")) == 1);
-    BOOST_CHECK(pt.count(T("key3")) == 0);
-    BOOST_CHECK(pt.count(T("KEY3")) == 0);
+    BOOST_TEST(pt.count(T("key1")) == 3);
+    BOOST_TEST(pt.count(T("KEY1")) == 1);
+    BOOST_TEST(pt.count(T("key2")) == 0);
+    BOOST_TEST(pt.count(T("KEY2")) == 1);
+    BOOST_TEST(pt.count(T("key3")) == 0);
+    BOOST_TEST(pt.count(T("KEY3")) == 0);
 #else
-    BOOST_CHECK(pt.count(T("key1")) == 3);
-    BOOST_CHECK(pt.count(T("KEY1")) == 3);
-    BOOST_CHECK(pt.count(T("key2")) == 1);
-    BOOST_CHECK(pt.count(T("KEY2")) == 1);
-    BOOST_CHECK(pt.count(T("key3")) == 0);
-    BOOST_CHECK(pt.count(T("KEY3")) == 0);
+    BOOST_TEST(pt.count(T("key1")) == 3);
+    BOOST_TEST(pt.count(T("KEY1")) == 3);
+    BOOST_TEST(pt.count(T("key2")) == 1);
+    BOOST_TEST(pt.count(T("KEY2")) == 1);
+    BOOST_TEST(pt.count(T("key3")) == 0);
+    BOOST_TEST(pt.count(T("KEY3")) == 0);
 #endif
 
 }
@@ -485,10 +485,10 @@ void test_comparison(PTREE *)
     {
         PTREE pt1(pt_orig);
         PTREE pt2(pt_orig);
-        BOOST_CHECK(pt1 == pt2);
-        BOOST_CHECK(pt2 == pt1);
-        BOOST_CHECK(!(pt1 != pt2));
-        BOOST_CHECK(!(pt2 != pt1));
+        BOOST_TEST(pt1 == pt2);
+        BOOST_TEST(pt2 == pt1);
+        BOOST_TEST(!(pt1 != pt2));
+        BOOST_TEST(!(pt2 != pt1));
     }
 
     // Test originals with modified case
@@ -498,10 +498,10 @@ void test_comparison(PTREE *)
         PTREE pt2(pt_orig);
         pt1.pop_back();
         pt1.put(T("KEY2"), T("data4"));
-        BOOST_CHECK(pt1 == pt2);
-        BOOST_CHECK(pt2 == pt1);
-        BOOST_CHECK(!(pt1 != pt2));
-        BOOST_CHECK(!(pt2 != pt1));
+        BOOST_TEST(pt1 == pt2);
+        BOOST_TEST(pt2 == pt1);
+        BOOST_TEST(!(pt1 != pt2));
+        BOOST_TEST(!(pt2 != pt1));
     }
 #endif
 
@@ -511,10 +511,10 @@ void test_comparison(PTREE *)
         PTREE pt2(pt_orig);
         pt1.put(T("key1.key5"), T("."));
         pt2.put(T("key1.key5"), T("."));
-        BOOST_CHECK(pt1 == pt2);
-        BOOST_CHECK(pt2 == pt1);
-        BOOST_CHECK(!(pt1 != pt2));
-        BOOST_CHECK(!(pt2 != pt1));
+        BOOST_TEST(pt1 == pt2);
+        BOOST_TEST(pt2 == pt1);
+        BOOST_TEST(!(pt1 != pt2));
+        BOOST_TEST(!(pt2 != pt1));
     }
 
     // Test modified copies (modified root data)
@@ -523,10 +523,10 @@ void test_comparison(PTREE *)
         PTREE pt2(pt_orig);
         pt1.data() = T("a");
         pt2.data() = T("b");
-        BOOST_CHECK(!(pt1 == pt2));
-        BOOST_CHECK(!(pt2 == pt1));
-        BOOST_CHECK(pt1 != pt2);
-        BOOST_CHECK(pt2 != pt1);
+        BOOST_TEST(!(pt1 == pt2));
+        BOOST_TEST(!(pt2 == pt1));
+        BOOST_TEST(pt1 != pt2);
+        BOOST_TEST(pt2 != pt1);
     }
 
     // Test modified copies (added subkeys with different data)
@@ -535,10 +535,10 @@ void test_comparison(PTREE *)
         PTREE pt2(pt_orig);
         pt1.put(T("key1.key5"), T("a"));
         pt2.put(T("key1.key5"), T("b"));
-        BOOST_CHECK(!(pt1 == pt2));
-        BOOST_CHECK(!(pt2 == pt1));
-        BOOST_CHECK(pt1 != pt2);
-        BOOST_CHECK(pt2 != pt1);
+        BOOST_TEST(!(pt1 == pt2));
+        BOOST_TEST(!(pt2 == pt1));
+        BOOST_TEST(pt1 != pt2);
+        BOOST_TEST(pt2 != pt1);
     }
 
     // Test modified copies (added subkeys with different keys)
@@ -547,10 +547,10 @@ void test_comparison(PTREE *)
         PTREE pt2(pt_orig);
         pt1.put(T("key1.key5"), T(""));
         pt2.put(T("key1.key6"), T(""));
-        BOOST_CHECK(!(pt1 == pt2));
-        BOOST_CHECK(!(pt2 == pt1));
-        BOOST_CHECK(pt1 != pt2);
-        BOOST_CHECK(pt2 != pt1);
+        BOOST_TEST(!(pt1 == pt2));
+        BOOST_TEST(!(pt2 == pt1));
+        BOOST_TEST(pt1 != pt2);
+        BOOST_TEST(pt2 != pt1);
     }
 
     // Test modified copies (added subkey to only one copy)
@@ -558,10 +558,10 @@ void test_comparison(PTREE *)
         PTREE pt1(pt_orig);
         PTREE pt2(pt_orig);
         pt1.put(T("key1.key5"), T(""));
-        BOOST_CHECK(!(pt1 == pt2));
-        BOOST_CHECK(!(pt2 == pt1));
-        BOOST_CHECK(pt1 != pt2);
-        BOOST_CHECK(pt2 != pt1);
+        BOOST_TEST(!(pt1 == pt2));
+        BOOST_TEST(!(pt2 == pt1));
+        BOOST_TEST(pt1 != pt2);
+        BOOST_TEST(pt2 != pt1);
     }
 
 }
@@ -575,8 +575,8 @@ void test_front_back(PTREE *)
     pt.put(T("key2"), T(""));
 
     // Check front and back
-    BOOST_CHECK(pt.front().first == T("key1"));
-    BOOST_CHECK(pt.back().first == T("key2"));
+    BOOST_TEST(pt.front().first == T("key1"));
+    BOOST_TEST(pt.back().first == T("key2"));
 
 }
 
@@ -605,49 +605,49 @@ void test_get_put(PTREE *)
     PTREE &pt6 = pt.put(T("k5.k.k.k.t"), true);
 
     // Check instances count
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 17);
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 17);
 
     // Check if const char * version returns std::string
-    BOOST_CHECK(typeid(pt.get_value(T(""))) == typeid(str_t));
+    BOOST_TEST(typeid(pt.get_value(T(""))) == typeid(str_t));
     
     // Do extractions via get (throwing version)
-    BOOST_CHECK(pt.get<int>(T("k1")) == 1);
-    BOOST_CHECK(pt.get<long>(T("k1")) == 1);
-    BOOST_CHECK(pt.get<double>(T("k2.k")) == 2.5);
-    BOOST_CHECK(pt.get<float>(T("k2.k")) == 2.5f);
-    BOOST_CHECK(pt.get<str_t>(T("k3.k.k")) == str_t(T("ala ma kota")));
-    BOOST_CHECK(pt.get<CHTYPE>(T("k4.k.k.k")) == CHTYPE('c'));
-    BOOST_CHECK(pt.get<bool>(T("k5.k.k.k.f")) == false);
-    BOOST_CHECK(pt.get<bool>(T("k5.k.k.k.t")) == true);
+    BOOST_TEST(pt.get<int>(T("k1")) == 1);
+    BOOST_TEST(pt.get<long>(T("k1")) == 1);
+    BOOST_TEST(pt.get<double>(T("k2.k")) == 2.5);
+    BOOST_TEST(pt.get<float>(T("k2.k")) == 2.5f);
+    BOOST_TEST(pt.get<str_t>(T("k3.k.k")) == str_t(T("ala ma kota")));
+    BOOST_TEST(pt.get<CHTYPE>(T("k4.k.k.k")) == CHTYPE('c'));
+    BOOST_TEST(pt.get<bool>(T("k5.k.k.k.f")) == false);
+    BOOST_TEST(pt.get<bool>(T("k5.k.k.k.t")) == true);
 
     // Do extractions via get (default value version)
-    BOOST_CHECK(pt.get(T("k1"), 0) == 1);
-    BOOST_CHECK(pt.get(T("k1"), 0L) == 1);
-    BOOST_CHECK(pt.get(T("k2.k"), 0.0) == 2.5);
-    BOOST_CHECK(pt.get(T("k2.k"), 0.0f) == 2.5f);
-    BOOST_CHECK(pt.get(T("k3.k.k"), str_t()) == str_t(T("ala ma kota")));
-    BOOST_CHECK(pt.get(T("k3.k.k"), T("")) == T("ala ma kota"));
-    BOOST_CHECK(pt.get(T("k4.k.k.k"), CHTYPE('\0')) == CHTYPE('c'));
-    BOOST_CHECK(pt.get(T("k5.k.k.k.f"), true) == false);
-    BOOST_CHECK(pt.get(T("k5.k.k.k.t"), false) == true);
+    BOOST_TEST(pt.get(T("k1"), 0) == 1);
+    BOOST_TEST(pt.get(T("k1"), 0L) == 1);
+    BOOST_TEST(pt.get(T("k2.k"), 0.0) == 2.5);
+    BOOST_TEST(pt.get(T("k2.k"), 0.0f) == 2.5f);
+    BOOST_TEST(pt.get(T("k3.k.k"), str_t()) == str_t(T("ala ma kota")));
+    BOOST_TEST(pt.get(T("k3.k.k"), T("")) == T("ala ma kota"));
+    BOOST_TEST(pt.get(T("k4.k.k.k"), CHTYPE('\0')) == CHTYPE('c'));
+    BOOST_TEST(pt.get(T("k5.k.k.k.f"), true) == false);
+    BOOST_TEST(pt.get(T("k5.k.k.k.t"), false) == true);
 
     // Do extractions via get (optional version)
     opt_int = pt.get_optional<int>(T("k1"));
-    BOOST_CHECK(opt_int && *opt_int == 1);
+    BOOST_TEST(opt_int && *opt_int == 1);
     opt_long = pt.get_optional<long>(T("k1"));
-    BOOST_CHECK(opt_long && *opt_long == 1);
+    BOOST_TEST(opt_long && *opt_long == 1);
     opt_double = pt.get_optional<double>(T("k2.k"));
-    BOOST_CHECK(opt_double && *opt_double == 2.5);
+    BOOST_TEST(opt_double && *opt_double == 2.5);
     opt_float = pt.get_optional<float>(T("k2.k"));
-    BOOST_CHECK(opt_float && *opt_float == 2.5f);
+    BOOST_TEST(opt_float && *opt_float == 2.5f);
     opt_string = pt.get_optional<str_t>(T("k3.k.k"));
-    BOOST_CHECK(opt_string && *opt_string == str_t(T("ala ma kota")));
+    BOOST_TEST(opt_string && *opt_string == str_t(T("ala ma kota")));
     opt_char = pt.get_optional<CHTYPE>(T("k4.k.k.k"));
-    BOOST_CHECK(opt_char && *opt_char == CHTYPE('c'));
+    BOOST_TEST(opt_char && *opt_char == CHTYPE('c'));
     opt_bool = pt.get_optional<bool>(T("k5.k.k.k.f"));
-    BOOST_CHECK(opt_bool && *opt_bool == false);
+    BOOST_TEST(opt_bool && *opt_bool == false);
     opt_bool = pt.get_optional<bool>(T("k5.k.k.k.t"));
-    BOOST_CHECK(opt_bool && *opt_bool == true);
+    BOOST_TEST(opt_bool && *opt_bool == true);
 
     // Do insertions via put_value
     pt1.put_value(short(1));
@@ -658,43 +658,43 @@ void test_get_put(PTREE *)
     pt6.put_value(true);
 
     // Do extractions via get_value (throwing version)
-    BOOST_CHECK(pt1.get_value<int>() == 1);
-    BOOST_CHECK(pt1.get_value<long>() == 1);
-    BOOST_CHECK(pt2.get_value<double>() == 2.5);
-    BOOST_CHECK(pt2.get_value<float>() == 2.5f);
-    BOOST_CHECK(pt3.get_value<str_t>() == str_t(T("ala ma kota")));
-    BOOST_CHECK(pt4.get_value<CHTYPE>() == CHTYPE('c'));
-    BOOST_CHECK(pt5.get_value<bool>() == false);
-    BOOST_CHECK(pt6.get_value<bool>() == true);
+    BOOST_TEST(pt1.get_value<int>() == 1);
+    BOOST_TEST(pt1.get_value<long>() == 1);
+    BOOST_TEST(pt2.get_value<double>() == 2.5);
+    BOOST_TEST(pt2.get_value<float>() == 2.5f);
+    BOOST_TEST(pt3.get_value<str_t>() == str_t(T("ala ma kota")));
+    BOOST_TEST(pt4.get_value<CHTYPE>() == CHTYPE('c'));
+    BOOST_TEST(pt5.get_value<bool>() == false);
+    BOOST_TEST(pt6.get_value<bool>() == true);
 
     // Do extractions via get_value (default value version)
-    BOOST_CHECK(pt1.get_value(0) == 1);
-    BOOST_CHECK(pt1.get_value(0L) == 1);
-    BOOST_CHECK(pt2.get_value(0.0) == 2.5);
-    BOOST_CHECK(pt2.get_value(0.0f) == 2.5f);
-    BOOST_CHECK(pt3.get_value(str_t()) == str_t(T("ala ma kota")));
-    BOOST_CHECK(pt3.get_value(T("")) == T("ala ma kota"));
-    BOOST_CHECK(pt4.get_value(CHTYPE('\0')) == CHTYPE('c'));
-    BOOST_CHECK(pt5.get_value(true) == false);
-    BOOST_CHECK(pt6.get_value(false) == true);
+    BOOST_TEST(pt1.get_value(0) == 1);
+    BOOST_TEST(pt1.get_value(0L) == 1);
+    BOOST_TEST(pt2.get_value(0.0) == 2.5);
+    BOOST_TEST(pt2.get_value(0.0f) == 2.5f);
+    BOOST_TEST(pt3.get_value(str_t()) == str_t(T("ala ma kota")));
+    BOOST_TEST(pt3.get_value(T("")) == T("ala ma kota"));
+    BOOST_TEST(pt4.get_value(CHTYPE('\0')) == CHTYPE('c'));
+    BOOST_TEST(pt5.get_value(true) == false);
+    BOOST_TEST(pt6.get_value(false) == true);
 
     // Do extractions via get_value (optional version)
     opt_int = pt1.get_value_optional<int>();
-    BOOST_CHECK(opt_int && *opt_int == 1);
+    BOOST_TEST(opt_int && *opt_int == 1);
     opt_long = pt1.get_value_optional<long>();
-    BOOST_CHECK(opt_long && *opt_long == 1);
+    BOOST_TEST(opt_long && *opt_long == 1);
     opt_double = pt2.get_value_optional<double>();
-    BOOST_CHECK(opt_double && *opt_double == 2.5);
+    BOOST_TEST(opt_double && *opt_double == 2.5);
     opt_float = pt2.get_value_optional<float>();
-    BOOST_CHECK(opt_float && *opt_float == 2.5f);
+    BOOST_TEST(opt_float && *opt_float == 2.5f);
     opt_string = pt3.get_value_optional<str_t>();
-    BOOST_CHECK(opt_string && *opt_string == str_t(T("ala ma kota")));
+    BOOST_TEST(opt_string && *opt_string == str_t(T("ala ma kota")));
     opt_char = pt4.get_value_optional<CHTYPE>();
-    BOOST_CHECK(opt_char && *opt_char == CHTYPE('c'));
+    BOOST_TEST(opt_char && *opt_char == CHTYPE('c'));
     opt_bool = pt5.get_value_optional<bool>();
-    BOOST_CHECK(opt_bool && *opt_bool == false);
+    BOOST_TEST(opt_bool && *opt_bool == false);
     opt_bool = pt6.get_value_optional<bool>();
-    BOOST_CHECK(opt_bool && *opt_bool == true);
+    BOOST_TEST(opt_bool && *opt_bool == true);
 
     // Do incorrect extractions (throwing version)
     try
@@ -719,51 +719,51 @@ void test_get_put(PTREE *)
     }
 
     // Do incorrect extractions (default value version)
-    BOOST_CHECK(pt.get(T("k2.k"), -7) == -7);
-    BOOST_CHECK(pt.get(T("k3.k.k"), -7) == -7);
-    BOOST_CHECK(pt.get(T("k4.k.k.k"), -7) == -7);
+    BOOST_TEST(pt.get(T("k2.k"), -7) == -7);
+    BOOST_TEST(pt.get(T("k3.k.k"), -7) == -7);
+    BOOST_TEST(pt.get(T("k4.k.k.k"), -7) == -7);
 
     // Do incorrect extractions (optional version)
-    BOOST_CHECK(!pt.get_optional<int>(T("k2.k")));
-    BOOST_CHECK(!pt.get_optional<int>(T("k3.k.k")));
-    BOOST_CHECK(!pt.get_optional<int>(T("k4.k.k.k")));
+    BOOST_TEST(!pt.get_optional<int>(T("k2.k")));
+    BOOST_TEST(!pt.get_optional<int>(T("k3.k.k")));
+    BOOST_TEST(!pt.get_optional<int>(T("k4.k.k.k")));
 
     // Test multiple puts with the same key
     {
         PTREE pt;
         pt.put(T("key"), 1);
-        BOOST_CHECK(pt.get<int>(T("key")) == 1);
-        BOOST_CHECK(pt.size() == 1);
+        BOOST_TEST(pt.get<int>(T("key")) == 1);
+        BOOST_TEST(pt.size() == 1);
         pt.put(T("key"), 2);
-        BOOST_CHECK(pt.get<int>(T("key")) == 2);
-        BOOST_CHECK(pt.size() == 1);
+        BOOST_TEST(pt.get<int>(T("key")) == 2);
+        BOOST_TEST(pt.size() == 1);
         pt.put(T("key.key.key"), 1);
         PTREE &child = pt.get_child(T("key.key"));
-        BOOST_CHECK(pt.get<int>(T("key.key.key")) == 1);
-        BOOST_CHECK(child.size() == 1);
-        BOOST_CHECK(child.count(T("key")) == 1);
+        BOOST_TEST(pt.get<int>(T("key.key.key")) == 1);
+        BOOST_TEST(child.size() == 1);
+        BOOST_TEST(child.count(T("key")) == 1);
         pt.put(T("key.key.key"), 2);
-        BOOST_CHECK(pt.get<int>(T("key.key.key")) == 2);
-        BOOST_CHECK(child.size() == 1);
-        BOOST_CHECK(child.count(T("key")) == 1);
+        BOOST_TEST(pt.get<int>(T("key.key.key")) == 2);
+        BOOST_TEST(child.size() == 1);
+        BOOST_TEST(child.count(T("key")) == 1);
     }
 
     // Test multiple puts with the same key
     {
         PTREE pt;
         pt.put(T("key"), 1);
-        BOOST_CHECK(pt.get<int>(T("key")) == 1);
-        BOOST_CHECK(pt.size() == 1);
+        BOOST_TEST(pt.get<int>(T("key")) == 1);
+        BOOST_TEST(pt.size() == 1);
         pt.put(T("key"), 2);
-        BOOST_CHECK(pt.get<int>(T("key")) == 2);
-        BOOST_CHECK(pt.size() == 1);
+        BOOST_TEST(pt.get<int>(T("key")) == 2);
+        BOOST_TEST(pt.size() == 1);
         pt.put(T("key.key.key"), 1);
         PTREE &child = pt.get_child(T("key.key"));
-        BOOST_CHECK(child.size() == 1);
-        BOOST_CHECK(child.count(T("key")) == 1);
+        BOOST_TEST(child.size() == 1);
+        BOOST_TEST(child.count(T("key")) == 1);
         pt.add(T("key.key.key"), 2);
-        BOOST_CHECK(child.size() == 2);
-        BOOST_CHECK(child.count(T("key")) == 2);
+        BOOST_TEST(child.size() == 2);
+        BOOST_TEST(child.count(T("key")) == 2);
     }
 
     // Test that put does not destroy children
@@ -771,11 +771,11 @@ void test_get_put(PTREE *)
         PTREE pt;
         pt.put(T("key1"), 1);
         pt.put(T("key1.key2"), 2);
-        BOOST_CHECK(pt.get<int>(T("key1"), 0) == 1);
-        BOOST_CHECK(pt.get<int>(T("key1.key2"), 0) == 2);
+        BOOST_TEST(pt.get<int>(T("key1"), 0) == 1);
+        BOOST_TEST(pt.get<int>(T("key1.key2"), 0) == 2);
         pt.put(T("key1"), 2);
-        BOOST_CHECK(pt.get<int>(T("key1"), 0) == 2);
-        BOOST_CHECK(pt.get<int>(T("key1.key2"), 0) == 2);
+        BOOST_TEST(pt.get<int>(T("key1"), 0) == 2);
+        BOOST_TEST(pt.get<int>(T("key1.key2"), 0) == 2);
     }
 
     // Test that get of single character that is whitespace works
@@ -783,14 +783,14 @@ void test_get_put(PTREE *)
         PTREE pt;
         pt.put_value(T(' '));
         CHTYPE ch = pt.get_value<CHTYPE>();
-        BOOST_CHECK(ch == T(' '));
+        BOOST_TEST(ch == T(' '));
     }
 
     // Test that get of non-char value with trailing and leading whitespace works
     {
         PTREE pt;
         pt.put_value(T(" \t\n99 \t\n"));
-        BOOST_CHECK(pt.get_value<int>(0) == 99);
+        BOOST_TEST(pt.get_value<int>(0) == 99);
     }
 
 }
@@ -810,44 +810,44 @@ void test_get_child_put_child(PTREE *)
     const PTREE &cpt1 = pt1, &cpt2 = pt2;
 
     // Do correct extractions via get_child (throwing version)
-    BOOST_CHECK(pt1.get_child(T("k1")).empty());
-    BOOST_CHECK(pt1.get_child(T("k2.k")).empty());
-    BOOST_CHECK(pt2.get_child(T("k1")) == pt);
-    BOOST_CHECK(pt2.get_child(T("k2.k")) == pt);
-    BOOST_CHECK(cpt1.get_child(T("k1")).empty());
-    BOOST_CHECK(cpt1.get_child(T("k2.k")).empty());
-    BOOST_CHECK(cpt2.get_child(T("k1")) == pt);
-    BOOST_CHECK(cpt2.get_child(T("k2.k")) == pt);
+    BOOST_TEST(pt1.get_child(T("k1")).empty());
+    BOOST_TEST(pt1.get_child(T("k2.k")).empty());
+    BOOST_TEST(pt2.get_child(T("k1")) == pt);
+    BOOST_TEST(pt2.get_child(T("k2.k")) == pt);
+    BOOST_TEST(cpt1.get_child(T("k1")).empty());
+    BOOST_TEST(cpt1.get_child(T("k2.k")).empty());
+    BOOST_TEST(cpt2.get_child(T("k1")) == pt);
+    BOOST_TEST(cpt2.get_child(T("k2.k")) == pt);
 
     // Do correct extractions via get_child (default value version)
-    BOOST_CHECK(pt1.get_child(T("k1"), PTREE(T("def"))) != PTREE(T("def")));
-    BOOST_CHECK(pt1.get_child(T("k2.k"), PTREE(T("def"))) != PTREE(T("def")));
-    BOOST_CHECK(pt2.get_child(T("k1"), PTREE(T("def"))) == pt);
-    BOOST_CHECK(pt2.get_child(T("k2.k"), PTREE(T("def"))) == pt);
-    BOOST_CHECK(cpt1.get_child(T("k1"), PTREE(T("def"))) != PTREE(T("def")));
-    BOOST_CHECK(cpt1.get_child(T("k2.k"), PTREE(T("def"))) != PTREE(T("def")));
-    BOOST_CHECK(cpt2.get_child(T("k1"), PTREE(T("def"))) == pt);
-    BOOST_CHECK(cpt2.get_child(T("k2.k"), PTREE(T("def"))) == pt);
+    BOOST_TEST(pt1.get_child(T("k1"), PTREE(T("def"))) != PTREE(T("def")));
+    BOOST_TEST(pt1.get_child(T("k2.k"), PTREE(T("def"))) != PTREE(T("def")));
+    BOOST_TEST(pt2.get_child(T("k1"), PTREE(T("def"))) == pt);
+    BOOST_TEST(pt2.get_child(T("k2.k"), PTREE(T("def"))) == pt);
+    BOOST_TEST(cpt1.get_child(T("k1"), PTREE(T("def"))) != PTREE(T("def")));
+    BOOST_TEST(cpt1.get_child(T("k2.k"), PTREE(T("def"))) != PTREE(T("def")));
+    BOOST_TEST(cpt2.get_child(T("k1"), PTREE(T("def"))) == pt);
+    BOOST_TEST(cpt2.get_child(T("k2.k"), PTREE(T("def"))) == pt);
 
     // Do correct extractions via get_child (optional version)
     boost::optional<PTREE &> opt;
     boost::optional<const PTREE &> copt;
     opt = pt1.get_child_optional(T("k1"));
-    BOOST_CHECK(opt);
+    BOOST_TEST(opt);
     opt = pt1.get_child_optional(T("k2.k"));
-    BOOST_CHECK(opt);
+    BOOST_TEST(opt);
     opt = pt2.get_child_optional(T("k1"));
-    BOOST_CHECK(opt && *opt == pt);
+    BOOST_TEST(opt && *opt == pt);
     opt = pt2.get_child_optional(T("k2.k"));
-    BOOST_CHECK(opt && *opt == pt);
+    BOOST_TEST(opt && *opt == pt);
     copt = cpt1.get_child_optional(T("k1"));
-    BOOST_CHECK(copt);
+    BOOST_TEST(copt);
     copt = cpt1.get_child_optional(T("k2.k"));
-    BOOST_CHECK(copt);
+    BOOST_TEST(copt);
     copt = cpt2.get_child_optional(T("k1"));
-    BOOST_CHECK(copt && *copt == pt);
+    BOOST_TEST(copt && *copt == pt);
     copt = cpt2.get_child_optional(T("k2.k"));
-    BOOST_CHECK(copt && *copt == pt);
+    BOOST_TEST(copt && *copt == pt);
 
     // Do incorrect extractions via get_child (throwing version)
     try
@@ -862,42 +862,42 @@ void test_get_child_put_child(PTREE *)
     }
 
     // Do incorrect extractions via get_child (default value version)
-    BOOST_CHECK(&pt.get_child(T("k2.k.bogus.path"), pt3) == &pt3);
+    BOOST_TEST(&pt.get_child(T("k2.k.bogus.path"), pt3) == &pt3);
 
     // Do incorrect extractions via get_child (optional version)
-    BOOST_CHECK(!pt.get_child_optional(T("k2.k.bogus.path")));
+    BOOST_TEST(!pt.get_child_optional(T("k2.k.bogus.path")));
 
     // Test multiple puts with the same key
     {
         PTREE pt, tmp1(T("data1")), tmp2(T("data2"));
         pt.put_child(T("key"), tmp1);
-        BOOST_CHECK(pt.get_child(T("key")) == tmp1);
-        BOOST_CHECK(pt.size() == 1);
+        BOOST_TEST(pt.get_child(T("key")) == tmp1);
+        BOOST_TEST(pt.size() == 1);
         pt.put_child(T("key"), tmp2);
-        BOOST_CHECK(pt.get_child(T("key")) == tmp2);
-        BOOST_CHECK(pt.size() == 1);
+        BOOST_TEST(pt.get_child(T("key")) == tmp2);
+        BOOST_TEST(pt.size() == 1);
         pt.put_child(T("key.key.key"), tmp1);
         PTREE &child = pt.get_child(T("key.key"));
-        BOOST_CHECK(child.size() == 1);
+        BOOST_TEST(child.size() == 1);
         pt.put_child(T("key.key.key"), tmp2);
-        BOOST_CHECK(child.size() == 1);
+        BOOST_TEST(child.size() == 1);
     }
 
     // Test multiple adds with the same key
     {
         PTREE pt, tmp1(T("data1")), tmp2(T("data2"));
         pt.add_child(T("key"), tmp1);
-        BOOST_CHECK(pt.size() == 1);
+        BOOST_TEST(pt.size() == 1);
         pt.add_child(T("key"), tmp2);
-        BOOST_CHECK(pt.size() == 2);
-        BOOST_CHECK(pt.count(T("key")) == 2);
+        BOOST_TEST(pt.size() == 2);
+        BOOST_TEST(pt.count(T("key")) == 2);
         pt.add_child(T("key.key.key"), tmp1);
         PTREE &child = pt.get_child(T("key.key"));
-        BOOST_CHECK(child.size() == 1);
-        BOOST_CHECK(child.count(T("key")) == 1);
+        BOOST_TEST(child.size() == 1);
+        BOOST_TEST(child.count(T("key")) == 1);
         pt.add_child(T("key.key.key"), tmp2);
-        BOOST_CHECK(child.size() == 2);
-        BOOST_CHECK(child.count(T("key")) == 2);
+        BOOST_TEST(child.size() == 2);
+        BOOST_TEST(child.count(T("key")) == 2);
     }
 
     // Test assigning child to tree
@@ -905,8 +905,8 @@ void test_get_child_put_child(PTREE *)
         PTREE pt;
         pt.put(T("foo.bar"), T("baz"));
         pt = pt.get_child(T("foo"));
-        BOOST_CHECK(pt.size() == 1);
-        BOOST_CHECK(pt.get< std::basic_string<CHTYPE> >(T("bar")) == T("baz"));
+        BOOST_TEST(pt.size() == 1);
+        BOOST_TEST(pt.get< std::basic_string<CHTYPE> >(T("bar")) == T("baz"));
     }
 
 }
@@ -921,9 +921,9 @@ void test_equal_range(PTREE *)
     pt.add_child(T("k1"), PTREE());
     pt.add_child(T("k2"), PTREE());
 
-    BOOST_CHECK(boost::distance(pt.equal_range(T("k1"))) == 3);
-    BOOST_CHECK(boost::distance(pt.equal_range(T("k2"))) == 2);
-    BOOST_CHECK(boost::distance(pt.equal_range(T("k3"))) == 1);
+    BOOST_TEST(boost::distance(pt.equal_range(T("k1"))) == 3);
+    BOOST_TEST(boost::distance(pt.equal_range(T("k2"))) == 2);
+    BOOST_TEST(boost::distance(pt.equal_range(T("k3"))) == 1);
 }
 
 void test_path_separator(PTREE *)
@@ -932,7 +932,7 @@ void test_path_separator(PTREE *)
     typedef PTREE::path_type path;
 
     // Check instances count
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 0);
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 0);
 
     // Do insertions
     PTREE pt;
@@ -944,21 +944,21 @@ void test_path_separator(PTREE *)
     pt.put(path(T("key6/key/key"), CHTYPE('/')), T("6"));
 
     // Check instances count
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 13);
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 13);
 
     // Do correct extractions
-    BOOST_CHECK(pt.get(T("key1"), 0) == 1);
-    BOOST_CHECK(pt.get(T("key2.key"), 0) == 2);
-    BOOST_CHECK(pt.get(T("key3.key.key"), 0) == 3);
-    BOOST_CHECK(pt.get(path(T("key4"), CHTYPE('/')), 0) == 4);
-    BOOST_CHECK(pt.get(path(T("key5/key"), CHTYPE('/')), 0) == 5);
-    BOOST_CHECK(pt.get(path(T("key6/key/key"), CHTYPE('/')), 0) == 6);
+    BOOST_TEST(pt.get(T("key1"), 0) == 1);
+    BOOST_TEST(pt.get(T("key2.key"), 0) == 2);
+    BOOST_TEST(pt.get(T("key3.key.key"), 0) == 3);
+    BOOST_TEST(pt.get(path(T("key4"), CHTYPE('/')), 0) == 4);
+    BOOST_TEST(pt.get(path(T("key5/key"), CHTYPE('/')), 0) == 5);
+    BOOST_TEST(pt.get(path(T("key6/key/key"), CHTYPE('/')), 0) == 6);
 
     // Do incorrect extractions
-    BOOST_CHECK(pt.get(T("key2/key"), 0) == 0);
-    BOOST_CHECK(pt.get(T("key3/key/key"), 0) == 0);
-    BOOST_CHECK(pt.get(path(T("key5.key"), CHTYPE('/')), 0) == 0);
-    BOOST_CHECK(pt.get(path(T("key6.key.key"), CHTYPE('/')), 0) == 0);
+    BOOST_TEST(pt.get(T("key2/key"), 0) == 0);
+    BOOST_TEST(pt.get(T("key3/key/key"), 0) == 0);
+    BOOST_TEST(pt.get(path(T("key5.key"), CHTYPE('/')), 0) == 0);
+    BOOST_TEST(pt.get(path(T("key6.key.key"), CHTYPE('/')), 0) == 0);
 
 }
 
@@ -975,14 +975,14 @@ void test_path(PTREE *)
     {
         path p;
         p /= T("key1"); p /= T("key2"); p /= T("key3");
-        BOOST_CHECK(pt.get<int>(p, 0) == 1);
+        BOOST_TEST(pt.get<int>(p, 0) == 1);
     }
 
     // Test operator /=
     {
         path p(T("key1"));
         p /= T("key2.key3");
-        BOOST_CHECK(pt.get<int>(p, 0) == 1);
+        BOOST_TEST(pt.get<int>(p, 0) == 1);
     }
 
     // Test operator /=
@@ -992,19 +992,19 @@ void test_path(PTREE *)
         path p2(T("key3"));
         p /= p1;
         p /= p2;
-        BOOST_CHECK(pt.get<int>(p, 0) == 1);
+        BOOST_TEST(pt.get<int>(p, 0) == 1);
     }
 
     // Test operator /
     {
         path p = path(T("key1")) / T("key2.key3");
-        BOOST_CHECK(pt.get<int>(p, 0) == 1);
+        BOOST_TEST(pt.get<int>(p, 0) == 1);
     }
 
     // Test operator /
     {
         path p = T("key1.key2") / path(T("key3"));
-        BOOST_CHECK(pt.get<int>(p, 0) == 1);
+        BOOST_TEST(pt.get<int>(p, 0) == 1);
     }
 
 }
@@ -1027,7 +1027,7 @@ void test_precision(PTREE *)
     real error = abs(pi - pi2) *
         pow(real(numeric_limits<real>::radix), 
             real(numeric_limits<real>::digits));
-    BOOST_CHECK(error < 100);
+    BOOST_TEST(error < 100);
 
 }
 
@@ -1051,8 +1051,8 @@ void test_locale(PTREE *)
         pt.put(T("french"), 1.234, translator(loc_french));
 
         // Test contents
-        BOOST_CHECK(pt.get<PTREE::data_type>(T("english")) == T("1.234"));
-        BOOST_CHECK(pt.get<PTREE::data_type>(T("french")) == T("1,234"));
+        BOOST_TEST(pt.get<PTREE::data_type>(T("english")) == T("1.234"));
+        BOOST_TEST(pt.get<PTREE::data_type>(T("french")) == T("1,234"));
 
     }
     catch (boost::property_tree::ptree_error &)
@@ -1081,20 +1081,20 @@ void test_custom_data_type(PTREE *)
     // Put/get int value
     pt.put(T("int value"), 3);
     int int_value = pt.get<int>(T("int value"));
-    BOOST_CHECK(int_value == 3);
+    BOOST_TEST(int_value == 3);
 
     // Put/get string value
     pt.put<std::basic_string<CHTYPE> >(T("string value"), T("foo bar"));
     std::basic_string<CHTYPE> string_value = pt.get<std::basic_string<CHTYPE> >(T("string value"));
-    BOOST_CHECK(string_value == T("foo bar"));
+    BOOST_TEST(string_value == T("foo bar"));
 
     // Put/get list<int> value
     int list_data[] = { 1, 2, 3, 4, 5 };
     pt.put<std::list<int> >(T("list value"), std::list<int>(list_data, list_data + sizeof(list_data) / sizeof(*list_data)));
     std::list<int> list_value = pt.get<std::list<int> >(T("list value"));
-    BOOST_CHECK(list_value.size() == 5);
-    BOOST_CHECK(list_value.front() == 1);
-    BOOST_CHECK(list_value.back() == 5);
+    BOOST_TEST(list_value.size() == 5);
+    BOOST_TEST(list_value.front() == 1);
+    BOOST_TEST(list_value.back() == 5);
 
 }
 
@@ -1102,19 +1102,19 @@ void test_empty_size_max_size(PTREE *)
 {
 
     PTREE pt;
-    BOOST_CHECK(pt.max_size());
-    BOOST_CHECK(pt.empty());
-    BOOST_CHECK(pt.size() == 0);
+    BOOST_TEST(pt.max_size());
+    BOOST_TEST(pt.empty());
+    BOOST_TEST(pt.size() == 0);
 
     pt.put(T("test1"), 1);
-    BOOST_CHECK(pt.max_size());
-    BOOST_CHECK(!pt.empty());
-    BOOST_CHECK(pt.size() == 1);
+    BOOST_TEST(pt.max_size());
+    BOOST_TEST(!pt.empty());
+    BOOST_TEST(pt.size() == 1);
 
     pt.put(T("test2"), 2);
-    BOOST_CHECK(pt.max_size());
-    BOOST_CHECK(!pt.empty());
-    BOOST_CHECK(pt.size() == 2);
+    BOOST_TEST(pt.max_size());
+    BOOST_TEST(!pt.empty());
+    BOOST_TEST(pt.size() == 2);
 
 }
 
@@ -1131,7 +1131,7 @@ void test_ptree_bad_path(PTREE *)
     {
         PTREE::path_type path = e.path<PTREE::path_type>();
         std::string what = e.what();
-        BOOST_CHECK(what.find("non.existent.path") != std::string::npos);
+        BOOST_TEST(what.find("non.existent.path") != std::string::npos);
         return;
     }
 
@@ -1155,7 +1155,7 @@ void test_ptree_bad_data(PTREE *)
         std::string what = e.what();
         // FIXME: Bring back what translation or make it more clear that it
         // doesn't work.
-        //BOOST_CHECK(what.find("non convertible to int") != std::string::npos);
+        //BOOST_TEST(what.find("non convertible to int") != std::string::npos);
         return;
     }
 
@@ -1187,7 +1187,7 @@ void test_serialization(PTREE *)
         boost::archive::text_iarchive ia(stream);
         PTREE pt2;
         ia & pt2;
-        BOOST_CHECK(pt1 == pt2);
+        BOOST_TEST(pt1 == pt2);
     }
     
     // Test binary archives
@@ -1198,7 +1198,7 @@ void test_serialization(PTREE *)
         boost::archive::binary_iarchive ia(stream);
         PTREE pt2;
         ia & pt2;
-        BOOST_CHECK(pt1 == pt2);
+        BOOST_TEST(pt1 == pt2);
     }
 
     // Test XML archives
@@ -1217,7 +1217,7 @@ void test_serialization(PTREE *)
             ia & boost::serialization::make_nvp("pt", pt2);
         }
 
-        BOOST_CHECK(pt1 == pt2);
+        BOOST_TEST(pt1 == pt2);
     }
 
 }
@@ -1239,17 +1239,17 @@ void test_bool(PTREE *)
 
     // Test false
     for (PTREE::iterator it = pt.get_child(T("bool.false")).begin(); it != pt.get_child(T("bool.false")).end(); ++it)
-        BOOST_CHECK(it->second.get_value<bool>() == false);
+        BOOST_TEST(it->second.get_value<bool>() == false);
 
     // Test true
     for (PTREE::iterator it = pt.get_child(T("bool.true")).begin(); it != pt.get_child(T("bool.true")).end(); ++it)
-        BOOST_CHECK(it->second.get_value<bool>() == true);
+        BOOST_TEST(it->second.get_value<bool>() == true);
 
     // Test invalid
     for (PTREE::iterator it = pt.get_child(T("bool.invalid")).begin(); it != pt.get_child(T("bool.invalid")).end(); ++it)
     {
-        BOOST_CHECK(it->second.get_value<bool>(false) == false);
-        BOOST_CHECK(it->second.get_value<bool>(true) == true);
+        BOOST_TEST(it->second.get_value<bool>(false) == false);
+        BOOST_TEST(it->second.get_value<bool>(true) == true);
     }
 
 }
@@ -1279,23 +1279,23 @@ void test_char(PTREE *)
 
     // Verify normal conversions
 #if WIDECHAR == 0
-    BOOST_CHECK(pt.get<char>(T("char")) == 'A');
+    BOOST_TEST(pt.get<char>(T("char")) == 'A');
 #endif
-    BOOST_CHECK(pt.get<schar>(T("signed char")) == static_cast<schar>('A'));
-    BOOST_CHECK(pt.get<uchar>(T("unsigned char")) == static_cast<uchar>('A'));
+    BOOST_TEST(pt.get<schar>(T("signed char")) == static_cast<schar>('A'));
+    BOOST_TEST(pt.get<uchar>(T("unsigned char")) == static_cast<uchar>('A'));
 
     // Verify that numbers are saved for signed and unsigned char
-    BOOST_CHECK(pt.get<int>(T("signed char")) == int('A'));
-    BOOST_CHECK(pt.get<int>(T("unsigned char")) == int('A'));
+    BOOST_TEST(pt.get<int>(T("signed char")) == int('A'));
+    BOOST_TEST(pt.get<int>(T("unsigned char")) == int('A'));
 
     // Verify ranges
-    BOOST_CHECK(pt.get<schar>(T("signed char min")) ==
+    BOOST_TEST(pt.get<schar>(T("signed char min")) ==
         (std::numeric_limits<schar>::min)());
-    BOOST_CHECK(pt.get<schar>(T("signed char max")) ==
+    BOOST_TEST(pt.get<schar>(T("signed char max")) ==
         (std::numeric_limits<schar>::max)());
-    BOOST_CHECK(pt.get<uchar>(T("unsigned char min")) ==
+    BOOST_TEST(pt.get<uchar>(T("unsigned char min")) ==
         (std::numeric_limits<uchar>::min)());
-    BOOST_CHECK(pt.get<uchar>(T("unsigned char max")) ==
+    BOOST_TEST(pt.get<uchar>(T("unsigned char max")) ==
         (std::numeric_limits<uchar>::max)());
 
     // Check that out-of-range throws.
@@ -1329,7 +1329,7 @@ void test_float(PTREE*)
     pt.put(T("num"), difficult);
     double result = pt.get<double>(T("num"));
 
-    BOOST_CHECK(!(result < difficult || result > difficult));
+    BOOST_TEST(!(result < difficult || result > difficult));
 }
 
 void test_sort(PTREE *)
@@ -1343,21 +1343,21 @@ void test_sort(PTREE *)
   pt.sort();
 
   PTREE::iterator it = pt.begin();
-  BOOST_CHECK(std::distance(it, pt.end()) == 4);
-  BOOST_CHECK(it->first == T("four"));
-  BOOST_CHECK(it->second.data() == T("v4"));
+  BOOST_TEST(std::distance(it, pt.end()) == 4);
+  BOOST_TEST(it->first == T("four"));
+  BOOST_TEST(it->second.data() == T("v4"));
   ++it;
-  BOOST_CHECK(it->first == T("one"));
-  BOOST_CHECK(it->second.data() == T("v1"));
+  BOOST_TEST(it->first == T("one"));
+  BOOST_TEST(it->second.data() == T("v1"));
   ++it;
-  BOOST_CHECK(it->first == T("three"));
-  BOOST_CHECK(it->second.data() == T("v3"));
+  BOOST_TEST(it->first == T("three"));
+  BOOST_TEST(it->second.data() == T("v3"));
   ++it;
-  BOOST_CHECK(it->first == T("two"));
-  BOOST_CHECK(it->second.data() == T("v2"));
+  BOOST_TEST(it->first == T("two"));
+  BOOST_TEST(it->second.data() == T("v2"));
 }
 
 void test_leaks(PTREE *)
 {
-    //BOOST_CHECK(PTREE::debug_get_instances_count() == 0);
+    //BOOST_TEST(PTREE::debug_get_instances_count() == 0);
 }
diff --git a/test/test_utils.hpp b/test/test_utils.hpp
index 809f91f..4122e83 100644
--- a/test/test_utils.hpp
+++ b/test/test_utils.hpp
@@ -18,7 +18,7 @@
 #   define _CRT_SECURE_NO_DEPRECATE
 #endif
 
-#include <boost/test/minimal.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <boost/property_tree/detail/ptree_utils.hpp>
 #include <fstream>
 #include <cstring>
@@ -65,7 +65,7 @@ public:
             std::ofstream stream(name.c_str());
             using namespace std;
             stream.write(test_data, strlen(test_data));
-            BOOST_CHECK(stream.good());
+            BOOST_TEST(stream.good());
         }
     }
     ~test_file()
@@ -116,7 +116,7 @@ void generic_parser_test(Ptree &pt,
     rf(filename_out, pt2);     // Read file again
 
     // Compare original with read
-    BOOST_CHECK(pt == pt2);
+    BOOST_TEST(pt == pt2);
 
 }
 
@@ -160,9 +160,9 @@ void generic_parser_test_ok(ReadFunc rf,
             std::cerr << "Sizes: " << (unsigned)::total_size(pt) << ", " << (unsigned)::total_data_size(pt) << ", " << (unsigned)::total_keys_size(pt) << "\n";
 
         // Check total sizes
-        BOOST_CHECK(actual_total_size == total_size);
-        BOOST_CHECK(actual_data_size == total_data_size);
-        BOOST_CHECK(actual_keys_size == total_keys_size);
+        BOOST_TEST(actual_total_size == total_size);
+        BOOST_TEST(actual_data_size == total_data_size);
+        BOOST_TEST(actual_keys_size == total_keys_size);
 
     }
     catch (std::runtime_error &e)
@@ -205,8 +205,8 @@ void generic_parser_test_error(ReadFunc rf,
         }
         catch (Error &e)
         {
-            BOOST_CHECK(e.line() == expected_error_line);           // Test line number
-            BOOST_CHECK(pt == get_test_ptree<Ptree>());             // Test if error damaged contents
+            BOOST_TEST(e.line() == expected_error_line);           // Test line number
+            BOOST_TEST(pt == get_test_ptree<Ptree>());             // Test if error damaged contents
         }
         catch (...)
         {
@@ -246,7 +246,7 @@ void check_exact_roundtrip(ReadFunc rf, WriteFunc wf, const char *test_data) {
     std::cerr << "(progress) Roundtripped data:\n";
     errstream<Ch>() << out_stream.str();
     std::cerr << "\n-----\n";
-    BOOST_CHECK(native_test_data == out_stream.str());
+    BOOST_TEST(native_test_data == out_stream.str());
 }
 
 #endif
diff --git a/test/test_xml_parser_rapidxml.cpp b/test/test_xml_parser_rapidxml.cpp
index ed24e5f..2362f6d 100644
--- a/test/test_xml_parser_rapidxml.cpp
+++ b/test/test_xml_parser_rapidxml.cpp
@@ -17,7 +17,7 @@
 #include <boost/detail/utf8_codecvt_facet.hpp>
 #include <boost/detail/utf8_codecvt_facet.ipp>
 
-int test_main(int argc, char *argv[])
+int main(int , char *[])
 {
     using namespace boost::property_tree;
     test_xml_parser<ptree>();
@@ -30,5 +30,5 @@ int test_main(int argc, char *argv[])
     test_xml_parser<wptree>();
     test_xml_parser<wiptree>();
 #endif
-    return 0;
+    return boost::report_errors();
 }

From 1b41ec0a51bfa948b7ef0635a1d874fe98dc425f Mon Sep 17 00:00:00 2001
From: Richard Hodges <hodges.r@gmail.com>
Date: Thu, 11 Mar 2021 15:56:06 +0100
Subject: [PATCH 13/14] Add README.md

---
 README.md | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 README.md

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..c1a1318
--- /dev/null
+++ b/README.md
@@ -0,0 +1,22 @@
+# Maintainer
+
+This library is currently maintained by [Richard Hodges](mailto:hodges.r@gmail.com) with generous support 
+from the C++ Alliance.
+
+# Build Status
+
+Branch  | Status
+--------|-------
+develop | [![CI](https://github.com/boostorg/property_tree/actions/workflows/ci.yml/badge.svg?branch=develop)](https://github.com/boostorg/property_tree/actions/workflows/ci.yml)
+master  | [![CI](https://github.com/boostorg/property_tree/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/boostorg/property_tree/actions/workflows/ci.yml)
+
+# Licence
+
+This software is distributed under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
+
+# Original Work
+
+This library is the work of Marcin Kalicinski and Sebastian Redl<br/> 
+
+Copyright (C) 2002-2006 Marcin Kalicinski<br/>
+Copyright (C) 2009 Sebastian Redl

From b712ddffc893cadb6a1d8fd83cfdfb4549839468 Mon Sep 17 00:00:00 2001
From: Richard Hodges <hodges.r@gmail.com>
Date: Fri, 12 Mar 2021 18:46:12 +0100
Subject: [PATCH 14/14] Improve CML compatibility with Boost Superproject

---
 CMakeLists.txt | 95 ++++++++++++--------------------------------------
 1 file changed, 23 insertions(+), 72 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 20ead53..22516cf 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -5,20 +5,17 @@
 # Distributed under the Boost Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 #
-# Official repository: https://github.com/boostorg/json
+# Official repository: https://github.com/boostorg/property_tree
 #
 
 cmake_minimum_required(VERSION 3.5...3.19)
 
-set(BOOST_PROPERTY_TREE_VERSION 100)
-if(BOOST_SUPERPROJECT_VERSION)
-    set(BOOST_PROPERTY_TREE_VERSION ${BOOST_SUPERPROJECT_VERSION})
-endif()
+set(BOOST_PROPERTY_TREE_VERSION ${BOOST_SUPERPROJECT_VERSION})
 
 project(boost_property_tree VERSION "${BOOST_PROPERTY_TREE_VERSION}" LANGUAGES CXX)
 
-option(BOOST_PROPERTY_TREE_BUILD_TESTS "Build boost::property_tree tests" ON)
-option(BOOST_PROPERTY_TREE_BUILD_EXAMPLES "Build boost::property_tree examples" ON)
+option(BOOST_PROPERTY_TREE_BUILD_TESTS "Build boost::property_tree tests" ${BUILD_TESTING})
+option(BOOST_PROPERTY_TREE_BUILD_EXAMPLES "Build boost::property_tree examples" ${BOOST_PROPERTY_TREE_BUILD_TESTS})
 
 file(GLOB_RECURSE BOOST_PROPERTY_TREE_HEADERS $<$<VERSION_GREATER_EQUAL:${CMAKE_VERSION},3.12>:CONFIGURE_DEPENDS>
     include/boost/*.hpp
@@ -34,41 +31,32 @@ set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR}/include/boost PREFIX "" FILES ${BOOST_PROPERTY_TREE_HEADERS})
 source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR}/src PREFIX "" FILES ${BOOST_PROPERTY_TREE_SOURCES})
 
-# TODO: For Boost superproject, do we want to support header-only mode?
-#       Then, this needs to read `add_library(boost_json INTERFACE)`
-#       and related settings need to be INTERFACE-ed as well.
 add_library(boost_property_tree INTERFACE)
-#target_sources(boost_property_tree INTERFACE ${BOOST_PROPERTY_TREE_HEADERS} ${BOOST_PROPERTY_TREE_SOURCES})
 add_library(Boost::property_tree ALIAS boost_property_tree)
 
-#target_compile_features(boost_property_tree PUBLIC cxx_constexpr)
-
-# TODO: For Boost superproject, this may need to be INTERFACE setting.
-include(GNUInstallDirs)
-if(BOOST_SUPERPROJECT_VERSION)
-    target_include_directories(boost_property_tree INTERFACE include)
-else()
-    target_include_directories(boost_property_tree
-        INTERFACE
-            "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
-            "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
-    )
-endif()
+target_include_directories(boost_property_tree INTERFACE include)
 
 if(BOOST_SUPERPROJECT_VERSION)
     #
     # Building as part of Boost superproject tree, with Boost as dependency.
     #
     target_link_libraries(boost_property_tree
-        PUBLIC
-            Boost::boost
-            Boost::assert
-            Boost::config
-            Boost::container
-            Boost::exception
-            Boost::system
-            Boost::throw_exception
-            Boost::utility
+      INTERFACE
+        Boost::any
+        Boost::assert
+        Boost::bind
+        Boost::config
+        Boost::core
+        Boost::format
+        Boost::iterator
+        Boost::mpl
+        Boost::multi_index
+        Boost::optional
+        Boost::range
+        Boost::serialization
+        Boost::static_assert
+        Boost::throw_exception
+        Boost::type_traits
     )
 
 elseif(BOOST_PROPERTY_TREE_IN_BOOST_TREE)
@@ -98,46 +86,9 @@ else()
     )
 endif()
 
-if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND NOT BOOST_PROPERTY_TREE_IN_BOOST_TREE)
-    set_target_properties(boost_property_tree PROPERTIES EXPORT_NAME property_tree)
-    install(TARGETS boost_property_tree
-        EXPORT boost_property_tree_targets
-        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    )
-
-    install(EXPORT boost_property_tree_targets
-        FILE boost_property_tree-targets.cmake
-        NAMESPACE Boost::
-        DESTINATION lib/cmake/boost_property_tree
-    )
-
-    include(CMakePackageConfigHelpers)
-
-    configure_package_config_file(cmake/config.cmake.in
-        ${CMAKE_CURRENT_BINARY_DIR}/boost_property_tree-config.cmake
-        INSTALL_DESTINATION lib/cmake/boost_property_tree
-    )
-
-    write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/boost_property_tree-config-version.cmake
-        VERSION ${PROJECT_VERSION} COMPATIBILITY SameMajorVersion
-    )
-
-    install(FILES
-        ${CMAKE_CURRENT_BINARY_DIR}/boost_property_tree-config.cmake
-        ${CMAKE_CURRENT_BINARY_DIR}/boost_property_tree-config-version.cmake
-        DESTINATION lib/cmake/boost_property_tree
-    )
-
-    install(DIRECTORY include/ DESTINATION include)
-endif()
-
-if(BOOST_PROPERTY_TREE_BUILD_TESTS)
+if(BUILD_TESTING)
     include(CTest)
-    if(BUILD_TESTING)
-        add_subdirectory(test)
-    endif()
+    add_subdirectory(test)
 endif()
 
 if(BOOST_PROPERTY_TREE_BUILD_EXAMPLES)