]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 |
2 | // test_cyclic_ptrs.cpp | |
3 | ||
f67539c2 | 4 | // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . |
7c673cae FG |
5 | // Use, modification and distribution is subject to the Boost Software |
6 | // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at | |
7 | // http://www.boost.org/LICENSE_1_0.txt) | |
8 | ||
9 | // should pass compilation and execution | |
10 | ||
11 | #include <cstddef> // NULL | |
12 | #include <fstream> | |
13 | ||
14 | #include <cstdio> // remove | |
15 | #include <boost/config.hpp> | |
16 | #if defined(BOOST_NO_STDC_NAMESPACE) | |
f67539c2 | 17 | namespace std{ |
7c673cae FG |
18 | using ::remove; |
19 | } | |
20 | #endif | |
21 | ||
22 | #include "test_tools.hpp" | |
23 | #include <boost/core/no_exceptions_support.hpp> | |
24 | ||
25 | #include <boost/serialization/nvp.hpp> | |
7c673cae FG |
26 | #include <boost/serialization/base_object.hpp> |
27 | ||
28 | #include "A.hpp" | |
29 | #include "A.ipp" | |
30 | ||
31 | /////////////////////////////////////////////////////// | |
32 | // class with a member which refers to itself | |
33 | class J : public A | |
34 | { | |
35 | private: | |
36 | friend class boost::serialization::access; | |
37 | template<class Archive> | |
38 | void serialize(Archive &ar, const unsigned int /* file_version */){ | |
39 | ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(A); | |
40 | ar & BOOST_SERIALIZATION_NVP(j); | |
41 | } | |
42 | public: | |
43 | bool operator==(const J &rhs) const; | |
44 | J *j; | |
45 | J(J *_j) : j(_j) {} | |
46 | J() : j(NULL){} | |
47 | }; | |
48 | ||
49 | BOOST_CLASS_VERSION(J, 6) | |
50 | ||
51 | bool J::operator==(const J &rhs) const | |
52 | { | |
53 | return static_cast<const A &>(*this) == static_cast<const A &>(rhs); | |
54 | } | |
55 | ||
56 | /////////////////////////////////////////////////////// | |
57 | // class with members that refer to each other | |
58 | // this is an example of a class that, as written, cannot | |
59 | // be serialized with this system. The problem is that the | |
60 | // serialization of the first member - j1 , provokes serialization | |
61 | // of those objects which it points to either directly or indirectly. | |
62 | // When those objects are subsequently serialized, it is discovered | |
63 | // that have already been serialized through pointers. This is | |
f67539c2 | 64 | // detected by the system and an exception - pointer_conflict - |
7c673cae FG |
65 | // is thrown. Permiting this to go undetected would result in the |
66 | // creation of multiple equal objects rather than the original | |
f67539c2 | 67 | // structure. |
7c673cae FG |
68 | class K |
69 | { | |
70 | J j1; | |
71 | J j2; | |
72 | J j3; | |
73 | friend class boost::serialization::access; | |
74 | template<class Archive> | |
75 | void serialize( | |
76 | Archive &ar, | |
77 | const unsigned int /* file_version */ | |
78 | ){ | |
79 | ar & BOOST_SERIALIZATION_NVP(j1); | |
80 | ar & BOOST_SERIALIZATION_NVP(j2); | |
81 | ar & BOOST_SERIALIZATION_NVP(j3); | |
82 | } | |
83 | public: | |
84 | bool operator==(const K &rhs) const; | |
85 | K(); | |
86 | }; | |
87 | ||
88 | K::K() | |
89 | : j1(&j2), j2(&j3), j3(&j1) | |
90 | { | |
91 | } | |
92 | ||
93 | bool K::operator==(const K &rhs) const | |
94 | { | |
95 | return | |
96 | j1.j == & j2 | |
97 | && j2.j == & j3 | |
98 | && j3.j == & j1 | |
99 | && j1 == rhs.j1 | |
100 | && j2 == rhs.j2 | |
101 | && j3 == rhs.j3 | |
102 | ; | |
103 | } | |
104 | ||
105 | int test1(){ | |
106 | const char * testfile = boost::archive::tmpnam(NULL); | |
107 | BOOST_REQUIRE(NULL != testfile); | |
108 | ||
109 | J j1, j2; | |
110 | { | |
111 | test_ostream os(testfile, TEST_STREAM_FLAGS); | |
112 | test_oarchive oa(os, TEST_ARCHIVE_FLAGS); | |
113 | oa << BOOST_SERIALIZATION_NVP(j1); | |
114 | } | |
115 | { | |
116 | // try to read the archive | |
117 | test_istream is(testfile, TEST_STREAM_FLAGS); | |
118 | test_iarchive ia(is, TEST_ARCHIVE_FLAGS); | |
119 | ia >> BOOST_SERIALIZATION_NVP(j2); | |
120 | } | |
121 | BOOST_CHECK(j1 == j2); | |
122 | std::remove(testfile); | |
123 | return EXIT_SUCCESS; | |
124 | } | |
125 | ||
126 | int test2(){ | |
127 | const char * testfile = boost::archive::tmpnam(NULL); | |
128 | BOOST_REQUIRE(NULL != testfile); | |
129 | ||
130 | J *j1 = new J; | |
131 | j1->j = j1; | |
132 | J *j2 = reinterpret_cast<J *>(0xBAADF00D); | |
133 | { | |
134 | test_ostream os(testfile, TEST_STREAM_FLAGS); | |
135 | test_oarchive oa(os, TEST_ARCHIVE_FLAGS); | |
136 | oa << BOOST_SERIALIZATION_NVP(j1); | |
137 | } | |
138 | { | |
139 | // try to read the archive | |
140 | test_istream is(testfile, TEST_STREAM_FLAGS); | |
141 | test_iarchive ia(is, TEST_ARCHIVE_FLAGS); | |
142 | ia >> BOOST_SERIALIZATION_NVP(j2); | |
143 | } | |
144 | BOOST_CHECK(*j1 == *j2); | |
b32b8144 | 145 | delete j1; |
7c673cae FG |
146 | BOOST_CHECK(j2 == j2->j); |
147 | std::remove(testfile); | |
148 | return EXIT_SUCCESS; | |
149 | } | |
150 | ||
151 | int test3(){ | |
152 | const char * testfile = boost::archive::tmpnam(NULL); | |
153 | BOOST_REQUIRE(NULL != testfile); | |
154 | ||
155 | K k; | |
156 | boost::archive::archive_exception exception( | |
157 | boost::archive::archive_exception::no_exception | |
158 | ); | |
f67539c2 | 159 | { |
7c673cae FG |
160 | test_ostream os(testfile, TEST_STREAM_FLAGS); |
161 | test_oarchive oa(os, TEST_ARCHIVE_FLAGS); | |
162 | BOOST_TRY { | |
163 | oa << BOOST_SERIALIZATION_NVP(k); | |
164 | } | |
92f5a8d4 | 165 | BOOST_CATCH (boost::archive::archive_exception const& ae){ |
7c673cae FG |
166 | exception = ae; |
167 | } | |
168 | BOOST_CATCH_END | |
169 | BOOST_CHECK( | |
170 | exception.code == boost::archive::archive_exception::pointer_conflict | |
171 | ); | |
172 | } | |
173 | // if exception wasn't invoked | |
174 | if(exception.code == boost::archive::archive_exception::no_exception){ | |
175 | // try to read the archive | |
176 | test_istream is(testfile, TEST_STREAM_FLAGS); | |
177 | test_iarchive ia(is, TEST_ARCHIVE_FLAGS); | |
178 | exception = boost::archive::archive_exception( | |
179 | boost::archive::archive_exception::no_exception | |
180 | ); | |
181 | BOOST_TRY { | |
182 | ia >> BOOST_SERIALIZATION_NVP(k); | |
183 | } | |
92f5a8d4 | 184 | BOOST_CATCH (boost::archive::archive_exception const& ae){ |
7c673cae FG |
185 | exception = ae; |
186 | } | |
187 | BOOST_CATCH_END | |
188 | BOOST_CHECK( | |
189 | exception.code == boost::archive::archive_exception::pointer_conflict | |
190 | ); | |
191 | } | |
192 | std::remove(testfile); | |
193 | return EXIT_SUCCESS; | |
194 | } | |
195 | ||
196 | int test_main( int /* argc */, char* /* argv */[] ){ | |
197 | test1(); | |
198 | test2(); | |
199 | test3(); | |
200 | return EXIT_SUCCESS; | |
201 | } | |
202 | ||
203 | // EOF |