Line data Source code
1 : #define BOOST_TEST_DYN_LINK
2 : #define BOOST_TEST_MODULE (MergeOverwrite test)
3 :
4 : #include <boost/test/unit_test.hpp>
5 :
6 : #include <algorithm>
7 : #include <iostream>
8 : #include <memory>
9 : #include <set>
10 : #include <string>
11 :
12 : #include "../DatabaseConfigurationInterface.h"
13 :
14 : using namespace ots;
15 :
16 : struct MergeOverwriteTestData {
17 2 : MergeOverwriteTestData() {
18 2 : srand(time(nullptr));
19 2 : baseVersion = rand() % 99999 + 100000;
20 2 : std::cout << "=== MERGE-BASED OVERWRITE TEST SUITE ===\n";
21 2 : std::cout << "Base version: " << baseVersion << "\n";
22 2 : }
23 :
24 2 : ~MergeOverwriteTestData() { std::cout << "\n=== TEST SUITE COMPLETE ===\n"; }
25 :
26 28 : int createConfig001(DatabaseConfigurationInterface& ifc, int version) {
27 28 : std::shared_ptr<ConfigurationBase> cfg = std::make_shared<TestConfiguration001>();
28 28 : cfg->getView().version = version;
29 56 : return ifc.saveActiveVersion(cfg.get());
30 28 : }
31 :
32 10 : int createConfig002(DatabaseConfigurationInterface& ifc, int version) {
33 10 : std::shared_ptr<ConfigurationBase> cfg = std::make_shared<TestConfiguration002>();
34 10 : cfg->getView().version = version;
35 20 : return ifc.saveActiveVersion(cfg.get());
36 10 : }
37 :
38 68 : std::string config001Name() {
39 68 : std::shared_ptr<ConfigurationBase> cfg = std::make_shared<TestConfiguration001>();
40 136 : return cfg->getConfigurationName();
41 68 : }
42 :
43 26 : std::string config002Name() {
44 26 : std::shared_ptr<ConfigurationBase> cfg = std::make_shared<TestConfiguration002>();
45 52 : return cfg->getConfigurationName();
46 26 : }
47 :
48 : int baseVersion;
49 : };
50 :
51 : MergeOverwriteTestData fixture;
52 :
53 : BOOST_AUTO_TEST_SUITE(merge_overwrite_test)
54 :
55 4 : BOOST_AUTO_TEST_CASE(overwrite_same_content_succeeds) {
56 2 : std::cout << "\n=== TEST 1: Overwrite same content succeeds ===\n";
57 :
58 2 : auto ifc = DatabaseConfigurationInterface();
59 :
60 2 : int version1 = fixture.baseVersion;
61 2 : BOOST_REQUIRE_EQUAL(fixture.createConfig001(ifc, version1), 0);
62 2 : std::cout << "Step 1: Created version " << version1 << "\n";
63 :
64 2 : auto map1 = DatabaseConfigurationInterface::config_version_map_t{};
65 2 : map1[fixture.config001Name()] = version1;
66 :
67 2 : std::string compName = "OverwriteSame_" + std::to_string(fixture.baseVersion);
68 2 : BOOST_CHECK_NO_THROW(ifc.storeGlobalConfiguration(map1, compName));
69 2 : std::cout << "Step 2: Created composition '" << compName << "'\n";
70 :
71 2 : std::cout << "Step 3: Overwriting with same content (allowOverwrite=true)...\n";
72 2 : BOOST_CHECK_NO_THROW(ifc.storeGlobalConfiguration(map1, compName, true));
73 2 : std::cout << " Result: SUCCESS\n";
74 :
75 2 : auto loaded = ifc.loadGlobalConfiguration(compName);
76 2 : BOOST_CHECK_EQUAL(loaded.size(), 1);
77 2 : BOOST_CHECK_EQUAL(loaded[fixture.config001Name()], version1);
78 :
79 2 : std::cout << " Verified: Composition unchanged after overwrite\n";
80 2 : }
81 :
82 4 : BOOST_AUTO_TEST_CASE(overwrite_add_new_member) {
83 2 : std::cout << "\n=== TEST 2: Overwrite adding new member ===\n";
84 :
85 2 : auto ifc = DatabaseConfigurationInterface();
86 :
87 2 : int version1 = fixture.baseVersion + 10;
88 2 : int version2 = fixture.baseVersion + 11;
89 :
90 2 : BOOST_REQUIRE_EQUAL(fixture.createConfig001(ifc, version1), 0);
91 2 : BOOST_REQUIRE_EQUAL(fixture.createConfig002(ifc, version2), 0);
92 2 : std::cout << "Step 1: Created versions " << version1 << ", " << version2 << "\n";
93 :
94 2 : auto map1 = DatabaseConfigurationInterface::config_version_map_t{};
95 2 : map1[fixture.config001Name()] = version1;
96 :
97 2 : std::string compName = "OverwriteAdd_" + std::to_string(fixture.baseVersion);
98 2 : ifc.storeGlobalConfiguration(map1, compName);
99 2 : std::cout << "Step 2: Created composition with 1 member\n";
100 :
101 2 : auto initial = ifc.loadGlobalConfiguration(compName);
102 2 : BOOST_CHECK_EQUAL(initial.size(), 1);
103 :
104 2 : auto map2 = DatabaseConfigurationInterface::config_version_map_t{};
105 2 : map2[fixture.config001Name()] = version1;
106 2 : map2[fixture.config002Name()] = version2;
107 :
108 2 : std::cout << "Step 3: Overwriting to add new member...\n";
109 2 : BOOST_CHECK_NO_THROW(ifc.storeGlobalConfiguration(map2, compName, true));
110 2 : std::cout << " Result: SUCCESS\n";
111 :
112 2 : auto loaded = ifc.loadGlobalConfiguration(compName);
113 2 : BOOST_CHECK_EQUAL(loaded.size(), 2);
114 2 : BOOST_CHECK_EQUAL(loaded[fixture.config001Name()], version1);
115 2 : BOOST_CHECK_EQUAL(loaded[fixture.config002Name()], version2);
116 :
117 2 : std::cout << " Verified: Composition now has 2 members\n";
118 :
119 2 : auto foundComps = ifc.findCompositionsContaining(fixture.config002Name(), std::to_string(version2));
120 2 : bool found = (foundComps.find(compName) != foundComps.end());
121 2 : BOOST_CHECK_EQUAL(found, true);
122 :
123 2 : std::cout << " Verified: Reverse lookup finds new member\n";
124 2 : }
125 :
126 4 : BOOST_AUTO_TEST_CASE(overwrite_remove_member) {
127 2 : std::cout << "\n=== TEST 3: Overwrite removing member ===\n";
128 :
129 2 : auto ifc = DatabaseConfigurationInterface();
130 :
131 2 : int version1 = fixture.baseVersion + 20;
132 2 : int version2 = fixture.baseVersion + 21;
133 :
134 2 : BOOST_REQUIRE_EQUAL(fixture.createConfig001(ifc, version1), 0);
135 2 : BOOST_REQUIRE_EQUAL(fixture.createConfig002(ifc, version2), 0);
136 2 : std::cout << "Step 1: Created versions " << version1 << ", " << version2 << "\n";
137 :
138 2 : auto map1 = DatabaseConfigurationInterface::config_version_map_t{};
139 2 : map1[fixture.config001Name()] = version1;
140 2 : map1[fixture.config002Name()] = version2;
141 :
142 2 : std::string compName = "OverwriteRemove_" + std::to_string(fixture.baseVersion);
143 2 : ifc.storeGlobalConfiguration(map1, compName);
144 2 : std::cout << "Step 2: Created composition with 2 members\n";
145 :
146 2 : auto initial = ifc.loadGlobalConfiguration(compName);
147 2 : BOOST_CHECK_EQUAL(initial.size(), 2);
148 :
149 2 : auto map2 = DatabaseConfigurationInterface::config_version_map_t{};
150 2 : map2[fixture.config001Name()] = version1;
151 :
152 2 : std::cout << "Step 3: Overwriting to remove Config002...\n";
153 2 : BOOST_CHECK_NO_THROW(ifc.storeGlobalConfiguration(map2, compName, true));
154 2 : std::cout << " Result: SUCCESS\n";
155 :
156 2 : auto loaded = ifc.loadGlobalConfiguration(compName);
157 2 : BOOST_CHECK_EQUAL(loaded.size(), 1);
158 2 : BOOST_CHECK_EQUAL(loaded[fixture.config001Name()], version1);
159 :
160 2 : bool hasConfig002 = (loaded.find(fixture.config002Name()) != loaded.end());
161 2 : BOOST_CHECK_EQUAL(hasConfig002, false);
162 :
163 2 : std::cout << " Verified: Composition now has 1 member (Config002 removed)\n";
164 :
165 2 : auto foundComps = ifc.findCompositionsContaining(fixture.config002Name(), std::to_string(version2));
166 2 : bool stillFound = (foundComps.find(compName) != foundComps.end());
167 2 : BOOST_CHECK_EQUAL(stillFound, false);
168 :
169 2 : std::cout << " Verified: Reverse lookup no longer finds removed member\n";
170 2 : }
171 :
172 4 : BOOST_AUTO_TEST_CASE(overwrite_update_version) {
173 2 : std::cout << "\n=== TEST 4: Overwrite updating member version ===\n";
174 :
175 2 : auto ifc = DatabaseConfigurationInterface();
176 :
177 2 : int versionOld = fixture.baseVersion + 30;
178 2 : int versionNew = fixture.baseVersion + 31;
179 :
180 2 : BOOST_REQUIRE_EQUAL(fixture.createConfig001(ifc, versionOld), 0);
181 2 : BOOST_REQUIRE_EQUAL(fixture.createConfig001(ifc, versionNew), 0);
182 2 : std::cout << "Step 1: Created versions " << versionOld << " and " << versionNew << "\n";
183 :
184 2 : auto map1 = DatabaseConfigurationInterface::config_version_map_t{};
185 2 : map1[fixture.config001Name()] = versionOld;
186 :
187 2 : std::string compName = "OverwriteUpdate_" + std::to_string(fixture.baseVersion);
188 2 : ifc.storeGlobalConfiguration(map1, compName);
189 2 : std::cout << "Step 2: Created composition with version " << versionOld << "\n";
190 :
191 2 : auto map2 = DatabaseConfigurationInterface::config_version_map_t{};
192 2 : map2[fixture.config001Name()] = versionNew;
193 :
194 2 : std::cout << "Step 3: Overwriting to update version to " << versionNew << "...\n";
195 2 : BOOST_CHECK_NO_THROW(ifc.storeGlobalConfiguration(map2, compName, true));
196 2 : std::cout << " Result: SUCCESS\n";
197 :
198 2 : auto loaded = ifc.loadGlobalConfiguration(compName);
199 2 : BOOST_CHECK_EQUAL(loaded.size(), 1);
200 2 : BOOST_CHECK_EQUAL(loaded[fixture.config001Name()], versionNew);
201 :
202 2 : std::cout << " Verified: Composition now has version " << versionNew << "\n";
203 :
204 2 : auto foundOld = ifc.findCompositionsContaining(fixture.config001Name(), std::to_string(versionOld));
205 2 : bool oldFound = (foundOld.find(compName) != foundOld.end());
206 2 : BOOST_CHECK_EQUAL(oldFound, false);
207 :
208 2 : std::cout << " Verified: Reverse lookup for old version returns empty\n";
209 :
210 2 : auto foundNew = ifc.findCompositionsContaining(fixture.config001Name(), std::to_string(versionNew));
211 2 : bool newFound = (foundNew.find(compName) != foundNew.end());
212 2 : BOOST_CHECK_EQUAL(newFound, true);
213 :
214 2 : std::cout << " Verified: Reverse lookup for new version finds composition\n";
215 2 : }
216 :
217 4 : BOOST_AUTO_TEST_CASE(overwrite_complete_replacement) {
218 2 : std::cout << "\n=== TEST 5: Overwrite complete replacement ===\n";
219 :
220 2 : auto ifc = DatabaseConfigurationInterface();
221 :
222 2 : int versionA = fixture.baseVersion + 40;
223 2 : int versionB = fixture.baseVersion + 41;
224 2 : int versionC = fixture.baseVersion + 42;
225 :
226 2 : BOOST_REQUIRE_EQUAL(fixture.createConfig001(ifc, versionA), 0);
227 2 : BOOST_REQUIRE_EQUAL(fixture.createConfig001(ifc, versionC), 0);
228 2 : BOOST_REQUIRE_EQUAL(fixture.createConfig002(ifc, versionB), 0);
229 2 : std::cout << "Step 1: Created versions A=" << versionA << ", B=" << versionB << ", C=" << versionC << "\n";
230 :
231 2 : auto map1 = DatabaseConfigurationInterface::config_version_map_t{};
232 2 : map1[fixture.config001Name()] = versionA;
233 :
234 2 : std::string compName = "OverwriteReplace_" + std::to_string(fixture.baseVersion);
235 2 : ifc.storeGlobalConfiguration(map1, compName);
236 2 : std::cout << "Step 2: Created composition with Config001/v" << versionA << "\n";
237 :
238 2 : auto map2 = DatabaseConfigurationInterface::config_version_map_t{};
239 2 : map2[fixture.config001Name()] = versionC;
240 2 : map2[fixture.config002Name()] = versionB;
241 :
242 2 : std::cout << "Step 3: Complete replacement...\n";
243 2 : BOOST_CHECK_NO_THROW(ifc.storeGlobalConfiguration(map2, compName, true));
244 2 : std::cout << " Result: SUCCESS\n";
245 :
246 2 : auto loaded = ifc.loadGlobalConfiguration(compName);
247 2 : BOOST_CHECK_EQUAL(loaded.size(), 2);
248 2 : BOOST_CHECK_EQUAL(loaded[fixture.config001Name()], versionC);
249 2 : BOOST_CHECK_EQUAL(loaded[fixture.config002Name()], versionB);
250 :
251 2 : std::cout << " Verified: Composition replaced completely\n";
252 :
253 2 : auto foundA = ifc.findCompositionsContaining(fixture.config001Name(), std::to_string(versionA));
254 2 : BOOST_CHECK_EQUAL(foundA.find(compName) != foundA.end(), false);
255 :
256 2 : std::cout << " Verified: Old version A not in reverse lookup\n";
257 2 : }
258 :
259 4 : BOOST_AUTO_TEST_CASE(overwrite_without_flag_fails) {
260 2 : std::cout << "\n=== TEST 6: Overwrite without flag fails ===\n";
261 :
262 2 : auto ifc = DatabaseConfigurationInterface();
263 :
264 2 : int version1 = fixture.baseVersion + 50;
265 2 : BOOST_REQUIRE_EQUAL(fixture.createConfig001(ifc, version1), 0);
266 :
267 2 : auto map1 = DatabaseConfigurationInterface::config_version_map_t{};
268 2 : map1[fixture.config001Name()] = version1;
269 :
270 2 : std::string compName = "OverwriteNoFlag_" + std::to_string(fixture.baseVersion);
271 2 : ifc.storeGlobalConfiguration(map1, compName);
272 2 : std::cout << "Step 1: Created composition\n";
273 :
274 2 : std::cout << "Step 2: Attempting overwrite without flag...\n";
275 4 : BOOST_CHECK_THROW(ifc.storeGlobalConfiguration(map1, compName), std::runtime_error);
276 2 : std::cout << " Result: Exception thrown (as expected)\n";
277 :
278 2 : auto loaded = ifc.loadGlobalConfiguration(compName);
279 2 : BOOST_CHECK_EQUAL(loaded.size(), 1);
280 :
281 2 : std::cout << " Verified: Original composition preserved\n";
282 2 : }
283 :
284 4 : BOOST_AUTO_TEST_CASE(empty_composition_creation_rejected) {
285 2 : std::cout << "\n=== TEST 7: Empty composition creation rejected ===\n";
286 :
287 2 : auto ifc = DatabaseConfigurationInterface();
288 :
289 2 : auto emptyMap = DatabaseConfigurationInterface::config_version_map_t{};
290 2 : std::string compName = "EmptyComp_" + std::to_string(fixture.baseVersion);
291 :
292 2 : std::cout << "Attempting to create empty composition...\n";
293 4 : BOOST_CHECK_THROW(ifc.storeGlobalConfiguration(emptyMap, compName), std::exception);
294 2 : std::cout << " Result: Exception thrown (as expected)\n";
295 2 : std::cout << " Verified: Empty compositions are rejected with clear error\n";
296 2 : }
297 :
298 4 : BOOST_AUTO_TEST_CASE(overwrite_to_empty_rejected) {
299 2 : std::cout << "\n=== TEST 8: Overwrite to empty rejected ===\n";
300 :
301 2 : auto ifc = DatabaseConfigurationInterface();
302 :
303 2 : int version1 = fixture.baseVersion + 70;
304 2 : BOOST_REQUIRE_EQUAL(fixture.createConfig001(ifc, version1), 0);
305 :
306 2 : auto map1 = DatabaseConfigurationInterface::config_version_map_t{};
307 2 : map1[fixture.config001Name()] = version1;
308 :
309 2 : std::string compName = "OverwriteToEmpty_" + std::to_string(fixture.baseVersion);
310 2 : ifc.storeGlobalConfiguration(map1, compName);
311 2 : std::cout << "Step 1: Created composition with 1 member\n";
312 :
313 2 : auto emptyMap = DatabaseConfigurationInterface::config_version_map_t{};
314 :
315 2 : std::cout << "Step 2: Attempting to overwrite with empty map...\n";
316 4 : BOOST_CHECK_THROW(ifc.storeGlobalConfiguration(emptyMap, compName, true), std::exception);
317 2 : std::cout << " Result: Exception thrown (as expected)\n";
318 :
319 2 : auto loaded = ifc.loadGlobalConfiguration(compName);
320 2 : BOOST_CHECK_EQUAL(loaded.size(), 1);
321 2 : BOOST_CHECK_EQUAL(loaded[fixture.config001Name()], version1);
322 :
323 2 : std::cout << " Verified: Original composition preserved after failed overwrite\n";
324 2 : }
325 :
326 4 : BOOST_AUTO_TEST_CASE(three_versions_bug_regression) {
327 2 : std::cout << "\n=== TEST 9: Three Versions Bug regression test ===\n";
328 2 : std::cout << "This test verifies the fix for the 'Three Versions Bug'\n";
329 :
330 2 : auto ifc = DatabaseConfigurationInterface();
331 :
332 2 : int version1 = fixture.baseVersion + 80;
333 2 : int version2 = fixture.baseVersion + 81;
334 2 : int version3 = fixture.baseVersion + 82;
335 :
336 2 : BOOST_REQUIRE_EQUAL(fixture.createConfig001(ifc, version1), 0);
337 2 : BOOST_REQUIRE_EQUAL(fixture.createConfig001(ifc, version2), 0);
338 2 : BOOST_REQUIRE_EQUAL(fixture.createConfig001(ifc, version3), 0);
339 2 : std::cout << "Step 1: Created versions " << version1 << ", " << version2 << ", " << version3 << "\n";
340 :
341 2 : std::string compName = "ThreeVersionsBugTest_" + std::to_string(fixture.baseVersion);
342 :
343 2 : auto map1 = DatabaseConfigurationInterface::config_version_map_t{};
344 2 : map1[fixture.config001Name()] = version1;
345 2 : ifc.storeGlobalConfiguration(map1, compName);
346 2 : std::cout << "Step 2: Created composition with version " << version1 << "\n";
347 :
348 2 : auto map2 = DatabaseConfigurationInterface::config_version_map_t{};
349 2 : map2[fixture.config001Name()] = version2;
350 2 : ifc.storeGlobalConfiguration(map2, compName, true);
351 2 : std::cout << "Step 3: Overwrote with version " << version2 << "\n";
352 :
353 2 : auto map3 = DatabaseConfigurationInterface::config_version_map_t{};
354 2 : map3[fixture.config001Name()] = version3;
355 2 : ifc.storeGlobalConfiguration(map3, compName, true);
356 2 : std::cout << "Step 4: Overwrote with version " << version3 << "\n";
357 :
358 2 : auto loaded = ifc.loadGlobalConfiguration(compName);
359 :
360 2 : BOOST_CHECK_EQUAL(loaded.size(), 1);
361 2 : BOOST_CHECK_EQUAL(loaded[fixture.config001Name()], version3);
362 :
363 2 : std::cout << "Step 5: Verified composition has only version " << version3 << "\n";
364 :
365 2 : auto found1 = ifc.findCompositionsContaining(fixture.config001Name(), std::to_string(version1));
366 2 : BOOST_CHECK_MESSAGE(found1.find(compName) == found1.end(), "BUG: Version " << version1 << " should NOT be found in composition!");
367 :
368 2 : auto found2 = ifc.findCompositionsContaining(fixture.config001Name(), std::to_string(version2));
369 2 : BOOST_CHECK_MESSAGE(found2.find(compName) == found2.end(), "BUG: Version " << version2 << " should NOT be found in composition!");
370 :
371 2 : auto found3 = ifc.findCompositionsContaining(fixture.config001Name(), std::to_string(version3));
372 2 : BOOST_CHECK_MESSAGE(found3.find(compName) != found3.end(), "Version " << version3 << " should be found in composition");
373 :
374 2 : std::cout << "Step 6-8: Verified reverse lookups are correct\n";
375 2 : std::cout << " v" << version1 << " found: " << (found1.find(compName) != found1.end() ? "YES (BUG!)" : "NO (correct)") << "\n";
376 2 : std::cout << " v" << version2 << " found: " << (found2.find(compName) != found2.end() ? "YES (BUG!)" : "NO (correct)") << "\n";
377 2 : std::cout << " v" << version3 << " found: " << (found3.find(compName) != found3.end() ? "YES (correct)" : "NO (BUG!)") << "\n";
378 :
379 2 : std::cout << "\n SUCCESS: Three Versions Bug fix verified!\n";
380 2 : }
381 :
382 4 : BOOST_AUTO_TEST_CASE(multiple_overwrites_integrity) {
383 2 : std::cout << "\n=== TEST 10: Multiple overwrites preserve integrity ===\n";
384 :
385 2 : auto ifc = DatabaseConfigurationInterface();
386 :
387 2 : int v1 = fixture.baseVersion + 90;
388 2 : int v2 = fixture.baseVersion + 91;
389 2 : int v3 = fixture.baseVersion + 92;
390 2 : int v4 = fixture.baseVersion + 93;
391 :
392 2 : BOOST_REQUIRE_EQUAL(fixture.createConfig001(ifc, v1), 0);
393 2 : BOOST_REQUIRE_EQUAL(fixture.createConfig001(ifc, v3), 0);
394 2 : BOOST_REQUIRE_EQUAL(fixture.createConfig002(ifc, v2), 0);
395 2 : BOOST_REQUIRE_EQUAL(fixture.createConfig002(ifc, v4), 0);
396 :
397 2 : std::string compName = "MultiOverwrite_" + std::to_string(fixture.baseVersion);
398 :
399 2 : auto map1 = DatabaseConfigurationInterface::config_version_map_t{};
400 2 : map1[fixture.config001Name()] = v1;
401 2 : map1[fixture.config002Name()] = v2;
402 2 : ifc.storeGlobalConfiguration(map1, compName);
403 :
404 2 : auto map2 = DatabaseConfigurationInterface::config_version_map_t{};
405 2 : map2[fixture.config001Name()] = v3;
406 2 : map2[fixture.config002Name()] = v2;
407 2 : ifc.storeGlobalConfiguration(map2, compName, true);
408 :
409 2 : auto map3 = DatabaseConfigurationInterface::config_version_map_t{};
410 2 : map3[fixture.config001Name()] = v3;
411 2 : map3[fixture.config002Name()] = v4;
412 2 : ifc.storeGlobalConfiguration(map3, compName, true);
413 :
414 2 : auto map4 = DatabaseConfigurationInterface::config_version_map_t{};
415 2 : map4[fixture.config001Name()] = v3;
416 2 : ifc.storeGlobalConfiguration(map4, compName, true);
417 :
418 2 : auto loaded = ifc.loadGlobalConfiguration(compName);
419 2 : BOOST_CHECK_EQUAL(loaded.size(), 1);
420 2 : BOOST_CHECK_EQUAL(loaded[fixture.config001Name()], v3);
421 :
422 8 : auto checkReverseLookup = [&](const std::string& type, int version, bool shouldFind) {
423 8 : auto found = ifc.findCompositionsContaining(type, std::to_string(version));
424 8 : bool isFound = (found.find(compName) != found.end());
425 8 : BOOST_CHECK_EQUAL(isFound, shouldFind);
426 10 : };
427 :
428 2 : checkReverseLookup(fixture.config001Name(), v1, false);
429 2 : checkReverseLookup(fixture.config001Name(), v3, true);
430 2 : checkReverseLookup(fixture.config002Name(), v2, false);
431 2 : checkReverseLookup(fixture.config002Name(), v4, false);
432 :
433 2 : std::cout << " Verified: Multiple overwrites maintain integrity\n";
434 2 : }
435 :
436 : BOOST_AUTO_TEST_SUITE_END()
|
