1// ----------------------------------------------------------------------------
2// Copyright (C) 2002-2005 Marcin Kalicinski
3//
4// Distributed under the Boost Software License, Version 1.0.
5// (See accompanying file LICENSE_1_0.txt or copy at
6// http://www.boost.org/LICENSE_1_0.txt)
7//
8// For more information, see www.boost.org
9// ----------------------------------------------------------------------------
10#ifndef BOOST_PROPERTY_TREE_TEST_UTILS_INCLUDED
11#define BOOST_PROPERTY_TREE_TEST_UTILS_INCLUDED
12
13#define BOOST_PROPERTY_TREE_DEBUG // Enable ptree debugging
14#include <boost/property_tree/ptree.hpp>
15
16// Do not deprecate insecure CRT calls on VC8
17#if (defined(BOOST_MSVC) && (BOOST_MSVC >= 1400) && !defined(_CRT_SECURE_NO_DEPRECATE))
18# define _CRT_SECURE_NO_DEPRECATE
19#endif
20
21#include <boost/core/lightweight_test.hpp>
22#include <boost/property_tree/detail/ptree_utils.hpp>
23#include <fstream>
24#include <cstring>
25#include <sstream>
26
27template<class Ptree>
28typename Ptree::size_type total_size(const Ptree &pt)
29{
30 typename Ptree::size_type size = 1;
31 for (typename Ptree::const_iterator it = pt.begin(); it != pt.end(); ++it)
32 size += total_size(it->second);
33 return size;
34}
35
36template<class Ptree>
37typename Ptree::size_type total_keys_size(const Ptree &pt)
38{
39 typename Ptree::size_type size = 0;
40 for (typename Ptree::const_iterator it = pt.begin(); it != pt.end(); ++it)
41 {
42 size += it->first.size();
43 size += total_keys_size(it->second);
44 }
45 return size;
46}
47
48template<class Ptree>
49typename Ptree::size_type total_data_size(const Ptree &pt)
50{
51 typename Ptree::size_type size = pt.data().size();
52 for (typename Ptree::const_iterator it = pt.begin(); it != pt.end(); ++it)
53 size += total_data_size(it->second);
54 return size;
55}
56
57class test_file
58{
59public:
60 test_file(const char *test_data, const char *filename)
61 {
62 if (test_data && filename)
63 {
64 name = filename;
65 std::ofstream stream(name.c_str());
66 using namespace std;
67 stream.write(s: test_data, n: strlen(s: test_data));
68 BOOST_TEST(stream.good());
69 }
70 }
71 ~test_file()
72 {
73 if (!name.empty())
74 remove(filename: name.c_str());
75 }
76private:
77 std::string name;
78};
79
80template<class Ptree>
81Ptree get_test_ptree()
82{
83 using namespace boost::property_tree;
84 typedef typename Ptree::key_type Str;
85 Ptree pt;
86 pt.put_value(detail::widen<Str>("data0"));
87 pt.put(detail::widen<Str>("key1"), detail::widen<Str>("data1"));
88 pt.put(detail::widen<Str>("key1.key"), detail::widen<Str>("data2"));
89 pt.put(detail::widen<Str>("key2"), detail::widen<Str>("data3"));
90 pt.put(detail::widen<Str>("key2.key"), detail::widen<Str>("data4"));
91 return pt;
92}
93
94// Generic test for file parser
95template<class Ptree, class ReadFunc, class WriteFunc>
96void generic_parser_test(Ptree &pt,
97 ReadFunc rf,
98 WriteFunc wf,
99 const char *test_data_1,
100 const char *test_data_2,
101 const char *filename_1,
102 const char *filename_2,
103 const char *filename_out)
104{
105
106 using namespace boost::property_tree;
107
108 // Create test files
109 test_file file_1(test_data_1, filename_1);
110 test_file file_2(test_data_2, filename_2);
111 test_file file_out("", filename_out);
112
113 rf(filename_1, pt); // Read file
114 wf(filename_out, pt); // Write file
115 Ptree pt2;
116 rf(filename_out, pt2); // Read file again
117
118 // Compare original with read
119 BOOST_TEST(pt == pt2);
120
121}
122
123// Generic test for file parser with expected success
124template<class Ptree, class ReadFunc, class WriteFunc>
125void generic_parser_test_ok(ReadFunc rf,
126 WriteFunc wf,
127 const char *test_data_1,
128 const char *test_data_2,
129 const char *filename_1,
130 const char *filename_2,
131 const char *filename_out,
132 unsigned int total_size,
133 unsigned int total_data_size,
134 unsigned int total_keys_size)
135{
136
137 using namespace boost::property_tree;
138
139 std::cerr << "(progress) Starting generic parser test with test file \"" << filename_1 << "\"\n";
140
141 // Make sure no instances exist
142 //BOOST_CHECK(Ptree::debug_get_instances_count() == 0);
143
144 try
145 {
146
147 // Read file
148 Ptree pt;
149 generic_parser_test<Ptree, ReadFunc, WriteFunc>(pt, rf, wf,
150 test_data_1, test_data_2,
151 filename_1, filename_2, filename_out);
152
153 // Determine total sizes
154 typename Ptree::size_type actual_total_size = ::total_size(pt);
155 typename Ptree::size_type actual_data_size = ::total_data_size(pt);
156 typename Ptree::size_type actual_keys_size = ::total_keys_size(pt);
157 if (actual_total_size != total_size ||
158 actual_data_size != total_data_size ||
159 actual_keys_size != total_keys_size)
160 std::cerr << "Sizes: " << (unsigned)::total_size(pt) << ", " << (unsigned)::total_data_size(pt) << ", " << (unsigned)::total_keys_size(pt) << "\n";
161
162 // Check total sizes
163 BOOST_TEST(actual_total_size == total_size);
164 BOOST_TEST(actual_data_size == total_data_size);
165 BOOST_TEST(actual_keys_size == total_keys_size);
166
167 }
168 catch (std::runtime_error &e)
169 {
170 BOOST_ERROR(e.what());
171 }
172
173 // Test for leaks
174 //BOOST_CHECK(Ptree::debug_get_instances_count() == 0);
175
176}
177
178// Generic test for file parser with expected error
179template<class Ptree, class ReadFunc, class WriteFunc, class Error>
180void generic_parser_test_error(ReadFunc rf,
181 WriteFunc wf,
182 const char *test_data_1,
183 const char *test_data_2,
184 const char *filename_1,
185 const char *filename_2,
186 const char *filename_out,
187 unsigned long expected_error_line)
188{
189
190 std::cerr << "(progress) Starting generic parser test with test file \"" << filename_1 << "\"\n";
191
192 // Make sure no instances exist
193 //BOOST_CHECK(Ptree::debug_get_instances_count() == 0);
194
195 {
196
197 // Create ptree as a copy of test ptree (to test if read failure does not damage ptree)
198 Ptree pt(get_test_ptree<Ptree>());
199 try
200 {
201 generic_parser_test<Ptree, ReadFunc, WriteFunc>(pt, rf, wf,
202 test_data_1, test_data_2,
203 filename_1, filename_2, filename_out);
204 BOOST_ERROR("No required exception thrown");
205 }
206 catch (Error &e)
207 {
208 BOOST_TEST(e.line() == expected_error_line); // Test line number
209 BOOST_TEST(pt == get_test_ptree<Ptree>()); // Test if error damaged contents
210 }
211 catch (...)
212 {
213 BOOST_ERROR("Invalid exception type thrown");
214 throw;
215 }
216
217 }
218
219 // Test for leaks
220 //BOOST_CHECK(Ptree::debug_get_instances_count() == 0);
221
222}
223
224template <typename Ch> std::basic_ostream<Ch>& errstream();
225template <> inline
226std::basic_ostream<char>& errstream() { return std::cerr; }
227#ifndef BOOST_NO_CWCHAR
228template <> inline
229std::basic_ostream<wchar_t>& errstream() { return std::wcerr; }
230#endif
231
232template <class Ptree, class ReadFunc, class WriteFunc>
233void check_exact_roundtrip(ReadFunc rf, WriteFunc wf, const char *test_data) {
234 std::cerr << "(progress) Starting exact roundtrip test with test data:\n"
235 << test_data << "\n-----\n";
236 using namespace boost::property_tree;
237 typedef typename Ptree::key_type::value_type Ch;
238 typedef typename Ptree::key_type Str;
239 Str native_test_data = detail::widen<Str>(test_data);
240
241 std::basic_istringstream<Ch> in_stream(native_test_data);
242 std::basic_ostringstream<Ch> out_stream;
243 Ptree tree;
244 rf(in_stream, tree);
245 wf(out_stream, tree);
246 std::cerr << "(progress) Roundtripped data:\n";
247 errstream<Ch>() << out_stream.str();
248 std::cerr << "\n-----\n";
249 BOOST_TEST(native_test_data == out_stream.str());
250}
251
252#endif
253

source code of boost/libs/property_tree/test/test_utils.hpp