Imported from /home/lorry/working-area/delta_boost-tarball/boost_1_58_0.tar.bz2.HEADboost_1_58_0master

5 files changed, 160 insertions, 160 deletions

diff --git a/libs/property_tree/test/test_ini_parser.cpp b/libs/property_tree/test/test_ini_parser.cpp
index 6507bd353..2edb48cd4 100644
--- a/libs/property_tree/test/test_ini_parser.cpp
+++ b/libs/property_tree/test/test_ini_parser.cpp
@@ -12,6 +12,8 @@
 #include <boost/property_tree/ini_parser.hpp>
 #include <sstream>
 
+using namespace boost::property_tree;
+
 ///////////////////////////////////////////////////////////////////////////////
 // Test data
 
@@ -70,7 +72,7 @@ struct ReadFunc
     template<class Ptree>
     void operator()(const std::string &filename, Ptree &pt) const
     {
-        boost::property_tree::read_ini(filename, pt);
+        read_ini(filename, pt);
     }
 };
 
@@ -79,13 +81,12 @@ struct WriteFunc
     template<class Ptree>
     void operator()(const std::string &filename, const Ptree &pt) const
     {
-        boost::property_tree::write_ini(filename, pt);
+        write_ini(filename, pt);
     }
 };
 
 void test_erroneous_write(const boost::property_tree::ptree &pt)
 {
-    using namespace boost::property_tree;
     std::stringstream stream;
     try
     {
@@ -105,9 +106,6 @@ void test_erroneous_write(const boost::property_tree::ptree &pt)
 template<class Ptree>
 void test_ini_parser()
 {
-    
-    using namespace boost::property_tree;
-
     generic_parser_test_ok<Ptree, ReadFunc, WriteFunc>
     (
         ReadFunc(), WriteFunc(), ok_data_1, NULL, 
@@ -155,24 +153,10 @@ void test_ini_parser()
         ReadFunc(), WriteFunc(), error_data_2, NULL,
         "testerr2.ini", NULL, "testerr2out.ini", 3
     );
-
 }
 
-int test_main(int argc, char *argv[])
+void test_unmappable_trees()
 {
-
-    using namespace boost::property_tree;
-
-    test_ini_parser<ptree>();
-    test_ini_parser<iptree>();
-#ifndef BOOST_NO_CWCHAR
-    test_ini_parser<wptree>();
-    test_ini_parser<wiptree>();
-#endif
-
-    ///////////////////////////////////////////////////////////////////////////
-    // Too rich property tree tests
-
     // Test too deep ptrees
     {
         ptree pt;
@@ -205,7 +189,38 @@ int test_main(int argc, char *argv[])
         child.push_back(std::make_pair("key", ptree()));
         test_erroneous_write(pt);
     }
+}
+
+void test_other_trees()
+{
+    // Top-level keys must be written before any section.
+    {
+        ptree pt;
+        pt.put("section.innerkey", "v1");
+        pt.put("nosection", "v2");
+        std::stringstream s;
+        write_ini(s, pt);
+        s.clear();
+        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");
+    }
+}
+
+int test_main(int argc, char *argv[])
+{
+    test_ini_parser<ptree>();
+    test_ini_parser<iptree>();
+#ifndef BOOST_NO_CWCHAR
+    test_ini_parser<wptree>();
+    test_ini_parser<wiptree>();
+#endif
 
+    test_unmappable_trees();
+    test_other_trees();
+ 
     return 0;
 
 }
diff --git a/libs/property_tree/test/test_json_parser.cpp b/libs/property_tree/test/test_json_parser.cpp
index 0e6791923..33828d946 100644
--- a/libs/property_tree/test/test_json_parser.cpp
+++ b/libs/property_tree/test/test_json_parser.cpp
@@ -414,14 +414,39 @@ void test_json_parser()
 
 }
 
+void test_escaping_utf8()
+{
+    // This is cyrillic text encoded as UTF-8
+    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);
+}
+
+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);
+    // 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) ==
+        L"\\u041C\\u0430\\u043C\\u0430 "
+        L"\\u043C\\u044B\\u043B\\u0430 \\u0440\\u0430\\u043C\\u0443");
+}
+
 int test_main(int argc, char *argv[])
 {
     using namespace boost::property_tree;
     test_json_parser<ptree>();
     test_json_parser<iptree>();
+    test_escaping_utf8();
 #ifndef BOOST_NO_CWCHAR
     test_json_parser<wptree>();
     test_json_parser<wiptree>();
+    test_escaping_wide();
 #endif
     return 0;
 }
diff --git a/libs/property_tree/test/test_property_tree.cpp b/libs/property_tree/test/test_property_tree.cpp
index d9dd10bbd..55ff5a830 100644
--- a/libs/property_tree/test/test_property_tree.cpp
+++ b/libs/property_tree/test/test_property_tree.cpp
@@ -132,6 +132,40 @@ namespace boost { namespace property_tree {
 #   undef WIDECHAR
 #endif
 
+template <typename Ptree>
+void run_tests(Ptree* pt)
+{
+    test_debug(pt);
+    test_constructor_destructor_assignment(pt);
+    test_insertion(pt);
+    test_erasing(pt);
+    test_clear(pt);
+    test_pushpop(pt);
+    test_container_iteration(pt);
+    test_swap(pt);
+    test_sort_reverse(pt);
+    test_case(pt);
+    test_comparison(pt);
+    test_front_back(pt);
+    test_get_put(pt);
+    test_get_child_put_child(pt);
+    test_equal_range(pt);
+    test_path_separator(pt);
+    test_path(pt);
+    test_precision(pt);
+    test_locale(pt);
+    test_custom_data_type(pt);
+    test_empty_size_max_size(pt);
+    test_ptree_bad_path(pt);
+    test_ptree_bad_data(pt);
+    test_serialization(pt);
+    test_bool(pt);
+    test_char(pt);
+    test_float(pt);
+    test_sort(pt);
+    test_leaks(pt);                  // must be a final test
+}
+
 int test_main(int, char *[])
 {
     
@@ -140,138 +174,30 @@ int test_main(int, char *[])
     // char tests, case sensitive
     {
         ptree *pt = 0;
-        test_debug(pt);
-        test_constructor_destructor_assignment(pt);
-        test_insertion(pt);
-        test_erasing(pt);
-        test_clear(pt);
-        test_pushpop(pt);
-        test_container_iteration(pt);
-        test_swap(pt);
-        test_sort_reverse(pt);
-        test_case(pt);
-        test_comparison(pt);
-        test_front_back(pt);
-        test_get_put(pt);
-        test_get_child_put_child(pt);
-        test_equal_range(pt);
-        test_path_separator(pt);
-        test_path(pt);
-        test_precision(pt);
-        test_locale(pt);
-        test_custom_data_type(pt);
-        test_empty_size_max_size(pt);
-        test_ptree_bad_path(pt);
-        test_ptree_bad_data(pt);
-        test_serialization(pt);
-        test_bool(pt);
-        test_char(pt);
-        test_sort(pt);
-        test_leaks(pt);                  // must be a final test
+        run_tests(pt);
     }
-#if 0
+
     // wchar_t tests, case sensitive
 #ifndef BOOST_NO_CWCHAR
     {
         wptree *pt = 0;
-        test_debug(pt);
-        test_constructor_destructor_assignment(pt);
-        test_insertion(pt);
-        test_erasing(pt);
-        test_clear(pt);
-        test_pushpop(pt);
-        test_container_iteration(pt);
-        test_swap(pt);
-        test_sort_reverse(pt);
-        test_case(pt);
-        test_comparison(pt);
-        test_front_back(pt);
-        test_get_put(pt);
-        test_get_child_put_child(pt);
-        test_equal_range(pt);
-        test_path_separator(pt);
-        test_path(pt);
-        test_precision(pt);
-        test_locale(pt);
-        test_custom_data_type(pt);
-        test_empty_size_max_size(pt);
-        test_ptree_bad_path(pt);
-        test_ptree_bad_data(pt);
-        test_serialization(pt);
-        test_bool(pt);
-        test_char(pt);
-        test_sort(pt);
-        test_leaks(pt);                  // must be a final test
+        run_tests(pt);
     }
 #endif
 
     // char tests, case insensitive
     {
         iptree *pt = 0;
-        test_debug(pt);
-        test_constructor_destructor_assignment(pt);
-        test_insertion(pt);
-        test_erasing(pt);
-        test_clear(pt);
-        test_pushpop(pt);
-        test_container_iteration(pt);
-        test_swap(pt);
-        test_sort_reverse(pt);
-        test_case(pt);
-        test_comparison(pt);
-        test_front_back(pt);
-        test_get_put(pt);
-        test_get_child_put_child(pt);
-        test_equal_range(pt);
-        test_path_separator(pt);
-        test_path(pt);
-        test_precision(pt);
-        test_locale(pt);
-        test_custom_data_type(pt);
-        test_empty_size_max_size(pt);
-        test_ptree_bad_path(pt);
-        test_ptree_bad_data(pt);
-        test_serialization(pt);
-        test_bool(pt);
-        test_char(pt);
-        test_sort(pt);
-        test_leaks(pt);                  // must be a final test
+        run_tests(pt);
     }
 
     // wchar_t tests, case insensitive
 #ifndef BOOST_NO_CWCHAR
     {
         wiptree *pt = 0;
-        test_debug(pt);
-        test_constructor_destructor_assignment(pt);
-        test_insertion(pt);
-        test_erasing(pt);
-        test_clear(pt);
-        test_pushpop(pt);
-        test_container_iteration(pt);
-        test_swap(pt);
-        test_sort_reverse(pt);
-        test_case(pt);
-        test_comparison(pt);
-        test_front_back(pt);
-        test_get_put(pt);
-        test_get_child_put_child(pt);
-        test_equal_range(pt);
-        test_path_separator(pt);
-        test_path(pt);
-        test_precision(pt);
-        test_locale(pt);
-        test_custom_data_type(pt);
-        test_empty_size_max_size(pt);
-        test_ptree_bad_path(pt);
-        test_ptree_bad_data(pt);
-        test_serialization(pt);
-        test_bool(pt);
-        test_char(pt);
-        test_sort(pt);
-        test_leaks(pt);                  // must be a final test
+        run_tests(pt);
     }
 #endif
-#endif
+
     return 0;
 }
diff --git a/libs/property_tree/test/test_property_tree.hpp b/libs/property_tree/test/test_property_tree.hpp
index 9a0b1272f..4216945a1 100644
--- a/libs/property_tree/test/test_property_tree.hpp
+++ b/libs/property_tree/test/test_property_tree.hpp
@@ -1248,42 +1248,80 @@ void test_bool(PTREE *)
 
 void test_char(PTREE *)
 {
+    typedef signed char schar;
+    typedef unsigned char uchar;
 
     // Prepare test tree
     PTREE pt;
 #if WIDECHAR == 0
     pt.put(T("char"), char('A'));
 #endif
-    pt.put(T("signed char"), static_cast<signed char>('A'));
-    pt.put(T("unsigned char"), static_cast<unsigned char>('A'));
-    pt.put(T("signed char min"), (std::numeric_limits<signed char>::min)());
-    pt.put(T("signed char max"), (std::numeric_limits<signed char>::max)());
-    pt.put(T("unsigned char min"), (std::numeric_limits<unsigned char>::min)());
-    pt.put(T("unsigned char max"), (std::numeric_limits<unsigned char>::max)());
+    pt.put(T("signed char"), static_cast<schar>('A'));
+    pt.put(T("unsigned char"), static_cast<uchar>('A'));
+    pt.put(T("signed char min"), (std::numeric_limits<schar>::min)());
+    pt.put(T("signed char max"), (std::numeric_limits<schar>::max)());
+    pt.put(T("signed char underflow"),
+           static_cast<int>((std::numeric_limits<schar>::min)()) - 1);
+    pt.put(T("signed char overflow"),
+           static_cast<int>((std::numeric_limits<schar>::max)()) + 1);
+    pt.put(T("unsigned char min"), (std::numeric_limits<uchar>::min)());
+    pt.put(T("unsigned char max"), (std::numeric_limits<uchar>::max)());
+    pt.put(T("unsigned char overflow"),
+           static_cast<unsigned>((std::numeric_limits<uchar>::max)()) + 1);
 
     // Verify normal conversions
 #if WIDECHAR == 0
     BOOST_CHECK(pt.get<char>(T("char")) == 'A');
 #endif
-    BOOST_CHECK(pt.get<signed char>(T("signed char")) ==
-        static_cast<signed char>('A'));
-    BOOST_CHECK(pt.get<unsigned char>(T("unsigned char")) ==
-        static_cast<unsigned char>('A'));
+    BOOST_CHECK(pt.get<schar>(T("signed char")) == static_cast<schar>('A'));
+    BOOST_CHECK(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'));
 
     // Verify ranges
-    BOOST_CHECK(pt.get<signed char>(T("signed char min")) ==
-        (std::numeric_limits<signed char>::min)());
-    BOOST_CHECK(pt.get<signed char>(T("signed char max")) ==
-        (std::numeric_limits<signed char>::max)());
-    BOOST_CHECK(pt.get<unsigned char>(T("unsigned char min")) ==
-        (std::numeric_limits<unsigned char>::min)());
-    BOOST_CHECK(pt.get<unsigned char>(T("unsigned char max")) ==
-        (std::numeric_limits<unsigned char>::max)());
+    BOOST_CHECK(pt.get<schar>(T("signed char min")) ==
+        (std::numeric_limits<schar>::min)());
+    BOOST_CHECK(pt.get<schar>(T("signed char max")) ==
+        (std::numeric_limits<schar>::max)());
+    BOOST_CHECK(pt.get<uchar>(T("unsigned char min")) ==
+        (std::numeric_limits<uchar>::min)());
+    BOOST_CHECK(pt.get<uchar>(T("unsigned char max")) ==
+        (std::numeric_limits<uchar>::max)());
+
+    // Check that out-of-range throws.
+    try {
+        pt.get<schar>(T("signed char underflow"));
+        BOOST_ERROR("expected ptree_bad_data, but nothing was thrown");
+    } catch (boost::property_tree::ptree_bad_data&) {
+    } catch (...) {
+        BOOST_ERROR("expected ptree_bad_data, but something else was thrown");
+    }
+    try {
+        pt.get<schar>(T("signed char overflow"));
+        BOOST_ERROR("expected ptree_bad_data, but nothing was thrown");
+    } catch (boost::property_tree::ptree_bad_data&) {
+    } catch (...) {
+        BOOST_ERROR("expected ptree_bad_data, but something else was thrown");
+    }
+    try {
+        pt.get<uchar>(T("unsigned char overflow"));
+        BOOST_ERROR("expected ptree_bad_data, but nothing was thrown");
+    } catch (boost::property_tree::ptree_bad_data&) {
+    } catch (...) {
+        BOOST_ERROR("expected ptree_bad_data, but something else was thrown");
+    }
+}
+
+void test_float(PTREE*)
+{
+    const double difficult = -183.12345000098765e-10;
+    PTREE pt;
+    pt.put(T("num"), difficult);
+    double result = pt.get<double>(T("num"));
 
+    BOOST_CHECK(!(result < difficult || result > difficult));
 }
 
 void test_sort(PTREE *)
diff --git a/libs/property_tree/test/xml_parser_test_data.hpp b/libs/property_tree/test/xml_parser_test_data.hpp
index 8ed329753..d0b4c071c 100644
--- a/libs/property_tree/test/xml_parser_test_data.hpp
+++ b/libs/property_tree/test/xml_parser_test_data.hpp
@@ -743,13 +743,9 @@ const char *ok_data_4 =
     "</rss>\n";
 
 // Correct, with UTF-8 data
-const char ok_data_5[] = {
-  '<', '?', 'x', 'm', 'l', ' ', 'v', 'e', 'r', 's', 'i', 'o', 'n', '=', '"',
-  '1', '.', '0', '"', ' ', 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g', '=', '"',
-  'u', 't', 'f', '-', '8', '"', '?', '>', '\n', /*39 chars*/
-  '<', 'd', 'o', 'c', '>', -61, -92, '<', '/', 'd', 'o', 'c', '>',
-  0
-};
+const char ok_data_5[] =
+    "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" /*39 chars*/
+    "<doc>\xC3\xA4</doc>";
 
 // Erroneous
 const char *error_data_1 =